xlog_cuda/

semantic_transition.rs

//! Fixed-roster device-resident semantic action sampling.
//!
//! Inputs are bound before capture. Launch and replay do not observe the device;
//! terminal observation is explicit. RNG successors remain pending, not published
//! world state. Descriptor meanings belong to the retained semantic admission.

use crate::semantic_work::{ExecutionWork, ModelWorkEvent, ModelWorkKind, ModelWorkRecording};
mod learning_phase;
#[cfg(feature = "semantic-policy")]
mod model_evaluation;
mod prepared_replay;
pub use learning_phase::{
    SemanticLearningCopyReset, SemanticLearningPhase, SemanticLearningPhaseRecord,
    SemanticLearningPhaseTransition,
};
#[cfg(feature = "semantic-policy")]
pub use model_evaluation::{
    SemanticCompletedModelEvaluation, SemanticEvaluationCohort, SemanticModelEvaluation,
    SemanticModelEvaluationResult,
};
#[cfg(feature = "semantic-policy")]
pub use prepared_replay::SemanticCompletedReplayMaterials;
use prepared_replay::{PreparedReplayCustody, PreparedReplayDescriptor};
use sha2::{Digest, Sha256};
use std::{
    collections::{BTreeMap, BTreeSet},
    fmt,
    mem::size_of,
    sync::Arc,
};

use cudarc::driver::sys;
use xlog_core::{Result as XlogResult, XlogError};

use crate::cuda_graph::CapturedCudaGraph;
use crate::dlpack::DlpackManagedTensor;
use crate::launch::{CudaEnqueue, LaunchEnqueueError, LaunchRecorder};
use crate::memory::TrackedCudaSlice;
use crate::memory::{
    CudaColumn, DeviceAllocationProvenance, DeviceMemoryView, DeviceRead, GpuMemoryReservation,
};
use crate::provider::resident_schedule::{validate_execution_domain, ResidentExecutionDomain};
use crate::semantic_hypergraph::{
    material_bytes, material_u32, material_u64, SemanticMaterialReader, SemanticRootMaterial,
};
#[cfg(feature = "semantic-policy")]
use crate::semantic_hypergraph::{
    material_statement_key, SemanticStatementIdentity, SemanticSupportIdentity,
};
#[cfg(feature = "semantic-policy")]
use crate::semantic_training_view::SemanticTrainingCanaryRefusalReason;
use crate::semantic_training_view::{
    frozen_training_coefficients, SemanticSelectedTrainingView,
    SemanticTrainingCanaryRefusalRecord, SemanticTrainingCanaryResultRecord,
    SemanticTrainingDomain, SemanticTrainingObjective, SemanticTrainingViewArena,
    SemanticTrainingViewOrigin, SemanticTrainingViewOriginRecord, SemanticTrainingViewPort,
    SemanticTrainingViewRow, SemanticTrainingViewSelection,
};
use crate::{
    CudaFunction, CudaKernelProvider, CudaStream, DeviceRepr, LaunchAsync, LaunchConfig,
    SemanticAdmission, SemanticAdmissionLimits, SemanticAdmissionRecords, SemanticHypergraph,
    SemanticHypergraphCapacities, SemanticHypergraphError, SemanticInsertOutcome,
    SemanticRecordRole, SemanticRootHandle, SemanticRootSnapshot,
};

#[cfg(feature = "semantic-policy")]
type PreparedPolicyStorage = (
    PolicyBuffers,
    TrackedCudaSlice<u8>,
    TrackedCudaSlice<SemanticTransitionReceipt>,
    TrackedCudaSlice<DeviceState>,
);

/// Canonical 256-bit identity, preserving byte order without native-word conversion.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
pub struct Identity256([u8; 32]);

impl Identity256 {
    pub const fn from_bytes(bytes: [u8; 32]) -> Self {
        Self(bytes)
    }
    pub const fn as_bytes(&self) -> &[u8; 32] {
        &self.0
    }
}

/// A native observer executed during cold task binding. Implementations belong to
/// the program executor, not the CUDA substrate. Python accepts executable XLOG
/// source through that executor, never caller-provided answers or receipts.
/// A successful observation must complete all submitted work before returning
/// host results. An error may follow device submission, so the calling session
/// is poisoned and cannot reuse its previous task binding.
pub trait SemanticTaskProgram: fmt::Debug + Send + Sync {
    /// A cold, independently admitted mutable source bank. The observer may
    /// report expected truth but never chooses editable rules or fact order.
    fn editable_program(&self) -> Option<&crate::SemanticProgramAdmission> {
        None
    }

    fn observe(
        &self,
        provider: Arc<CudaKernelProvider>,
    ) -> Result<SemanticTaskObservation, SemanticTransitionError>;
}

/// Actual native observer output and the exact source/input/result custody used
/// to derive it. These bytes describe execution; they grant no application rights.
pub struct SemanticTaskObservation {
    pub program_source: Vec<u8>,
    pub input_bytes: Vec<u8>,
    pub result_bytes: Vec<u8>,
    pub expected_truth: [crate::SemanticTruth; 3],
}

/// Independently recomputable identities of the exact semantic task content.
/// These values carry no use authority. They let retained symbolic training
/// rows bind the ordered query, admitted theory plus executed observer program,
/// and observed four-valued result to the task that the native owner actually
/// executed during cold binding.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticTaskContentIdentity {
    pub query: Identity256,
    pub theory_program: Identity256,
    pub result: Identity256,
}

/// Explicit nonnegative coefficients for query agreement and measured work.
/// These coefficients determine the measured value and final return; ordered
/// task priorities, agreement, and cost select the candidate in that order.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticTaskScoring {
    pub correct_weight: u32,
    pub all_correct_weight: u32,
    pub work_weight: u32,
    pub improvement_weight: u32,
    pub refusal_weight: u32,
    pub spent_weight: u32,
}

/// Task-independent unit and finite cap for native structural work. The unit
/// names the versioned counting law and the resident program mode, not the
/// authority, task identity, or outcome of a sampled candidate.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticStructuralCostDescriptor {
    pub unit: Identity256,
    pub cap: u64,
}

/// Evaluator interval and objective coefficients frozen by the native task
/// before actions, independently of any future training-group membership.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SemanticTaskObjectiveLaw {
    pub return_bound: i64,
    pub evaluator_min: f64,
    pub evaluator_max: f64,
    pub coefficients: [f32; 9],
    pub structural_cost: SemanticStructuralCostDescriptor,
}

impl SemanticTaskObjectiveLaw {
    fn require_objective(
        self,
        objective: &SemanticTrainingObjective,
    ) -> Result<(), SemanticTransitionError> {
        if objective.evaluator_min.to_bits() != self.evaluator_min.to_bits()
            || objective.evaluator_max.to_bits() != self.evaluator_max.to_bits()
            || objective.coefficients.map(f32::to_bits) != self.coefficients.map(f32::to_bits)
            || objective.cost_unit != self.structural_cost.unit
            || objective.cost_cap != self.structural_cost.cap
        {
            return Err(publication_input_error(
                "training objective differs from the evaluator, coefficients or cost law frozen before actions",
            ));
        }
        Ok(())
    }
}

/// The only structural-cost law accepted by a cold training objective.
pub fn semantic_structural_cost_descriptor(
    editable_program: bool,
) -> SemanticStructuralCostDescriptor {
    let (support_cap, truth_change_cap) = if editable_program {
        (
            crate::semantic_program::RESIDENT_PROGRAM_FACT_CAPACITY as u64,
            3u64,
        )
    } else {
        (2u64, 2u64)
    };
    let cap = 2 + support_cap + truth_change_cap;
    let mut hash = Sha256::new();
    hash.update(b"xlog.semantic.structural-cost.v1\0");
    for word in [
        u64::from(editable_program),
        2,
        support_cap,
        truth_change_cap,
        cap,
    ] {
        hash.update(word.to_le_bytes());
    }
    SemanticStructuralCostDescriptor {
        unit: Identity256::from_bytes(hash.finalize().into()),
        cap,
    }
}

/// One normalized truth-match objective within an ordered task priority level.
/// The native query result contributes one when it equals `target_truth`, zero
/// otherwise; candidate progress subtracts the acquired base's contribution.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticTaskPriorityGoal {
    pub query: u8,
    pub target_truth: u8,
    pub weight: u32,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticTaskPriorityLevel {
    pub goals: Vec<SemanticTaskPriorityGoal>,
}

impl SemanticTaskScoring {
    fn words(self) -> [u64; 6] {
        [
            self.correct_weight,
            self.all_correct_weight,
            self.work_weight,
            self.improvement_weight,
            self.refusal_weight,
            self.spent_weight,
        ]
        .map(u64::from)
    }

    fn return_bound(self, editable_program: bool) -> Result<i64, SemanticTransitionError> {
        // A rule may derive many facts from one command. Successful resident
        // materialization caps the fact bank at 4096, and a candidate can also
        // change all three query truths. The graph-only path retains its smaller
        // support-attachment cap. Priority selection need not maximize value,
        // so both signs of selected-minus-base value must fit.
        let max_cost = u128::from(semantic_structural_cost_descriptor(editable_program).cap);
        let max_spent = if editable_program { 19 } else { 17 };
        let value_span = 3 * u128::from(self.correct_weight)
            + u128::from(self.all_correct_weight)
            + max_cost * u128::from(self.work_weight);
        i64::try_from(value_span)
            .map_err(|_| publication_input_error("task value can overflow signed arithmetic"))?;
        let return_bound = value_span * u128::from(self.improvement_weight)
            + 2 * u128::from(self.refusal_weight)
            + max_spent * u128::from(self.spent_weight);
        i64::try_from(return_bound)
            .map_err(|_| publication_input_error("task scoring can overflow the signed return"))
    }

    fn validate(self, editable_program: bool) -> Result<(), SemanticTransitionError> {
        self.return_bound(editable_program).map(|_| ())
    }

    fn objective_law(
        self,
        editable_program: bool,
    ) -> Result<SemanticTaskObjectiveLaw, SemanticTransitionError> {
        let return_bound = self.return_bound(editable_program)?;
        let mut evaluator_max = return_bound as f64;
        // The integer return bound may exceed exact FP64 integer precision.
        // Never narrow the proven interval when rounding its upper endpoint.
        if (evaluator_max as u128) < return_bound as u128 {
            evaluator_max = f64::from_bits(evaluator_max.to_bits() + 1);
        }
        let evaluator_min = -evaluator_max;
        Ok(SemanticTaskObjectiveLaw {
            return_bound,
            evaluator_min,
            evaluator_max,
            coefficients: frozen_training_coefficients(evaluator_min, evaluator_max),
            structural_cost: semantic_structural_cost_descriptor(editable_program),
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn completed_law_bytes(
        self,
        task_identity: Identity256,
        editable_program: bool,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        let mut bytes = b"XLOG-TASK-SCORING-LAW\0".to_vec();
        material_u64(&mut bytes, 2);
        bytes.extend_from_slice(task_identity.as_bytes());
        let structural_cost = semantic_structural_cost_descriptor(editable_program);
        bytes.extend_from_slice(structural_cost.unit.as_bytes());
        material_u64(&mut bytes, structural_cost.cap);
        for weight in self.words() {
            material_u64(&mut bytes, weight);
        }
        bytes.extend_from_slice(&self.return_bound(editable_program)?.to_le_bytes());
        Ok(bytes)
    }
}

fn checkpoint_scoring_law_identity(
    scoring: SemanticTaskScoring,
    task_content: SemanticTaskContentIdentity,
    objective_law: SemanticTaskObjectiveLaw,
    training_domain: Option<&SemanticTrainingDomain>,
) -> Identity256 {
    let mut hash = Sha256::new();
    hash.update(b"xlog.semantic.checkpoint.scoring-law.v4\0");
    // Arena transfer advances authority, not the task's content or evaluator.
    // The checkpoint binds that authority separately from this immutable law.
    for identity in [
        task_content.query,
        task_content.theory_program,
        task_content.result,
    ] {
        hash.update(identity.as_bytes());
    }
    for weight in scoring.words() {
        hash.update(weight.to_le_bytes());
    }
    hash.update(objective_law.return_bound.to_le_bytes());
    hash.update(objective_law.structural_cost.unit.as_bytes());
    hash.update(objective_law.structural_cost.cap.to_le_bytes());
    hash.update(objective_law.evaluator_min.to_bits().to_le_bytes());
    hash.update(objective_law.evaluator_max.to_bits().to_le_bytes());
    for coefficient in objective_law.coefficients {
        hash.update(coefficient.to_bits().to_le_bytes());
    }
    hash.update([u8::from(training_domain.is_some())]);
    if let Some(domain) = training_domain {
        hash.update(domain.identity().as_bytes());
    }
    Identity256::from_bytes(hash.finalize().into())
}

#[cfg(feature = "semantic-policy")]
#[expect(
    clippy::too_many_arguments,
    reason = "completed scoring checks independent task, work, refusal, and result fields"
)]
fn validate_completed_task_scoring(
    scoring: SemanticTaskScoring,
    editable_program: bool,
    priority_levels: &[SemanticTaskPriorityLevel],
    facts: &[SemanticTaskFacts; 3],
    work: &[SemanticTransitionWork; 2],
    lane_refusal: [u64; 2],
    query_count: u64,
    winner: u64,
    return_value: i64,
) -> bool {
    if scoring.validate(editable_program).is_err()
        || query_count > 9
        || winner > 2
        || lane_refusal.iter().any(|&refusal| refusal > 4)
        || (!editable_program && lane_refusal.iter().any(|&refusal| refusal >= 3))
        || work.iter().any(|work| !work.is_valid(editable_program))
        || facts
            .iter()
            .any(|facts| facts.g > 3 || facts.p > 1 || facts.eligible > 1)
    {
        return false;
    }
    for (slot, facts) in facts.iter().enumerate() {
        let measured = if slot == 0 {
            0
        } else {
            let work = work[slot - 1];
            work.raw_structural_cost()
        };
        let value = i128::from(scoring.correct_weight) * i128::from(facts.g)
            + i128::from(scoring.all_correct_weight) * i128::from(facts.p)
            - i128::from(scoring.work_weight) * i128::from(measured);
        if facts.c != measured || i128::from(facts.v) != value {
            return false;
        }
    }
    let mut selected = 0;
    for slot in 1..3 {
        if facts[slot].eligible == 1
            && (facts[selected].eligible == 0
                || task_candidate_better(priority_levels, facts, slot, selected))
        {
            selected = slot;
        }
    }
    if winner as usize != selected || facts[selected].eligible != 1 {
        return false;
    }
    let refusals = lane_refusal.iter().filter(|&&refusal| refusal != 0).count() as i128;
    let spent = i128::from(query_count)
        + work
            .iter()
            .enumerate()
            .filter(|(lane, _)| lane + 1 != selected)
            .map(|(_, work)| i128::from(work.edit_commands + work.defined_truth_changes))
            .sum::<i128>();
    let expected_return = i128::from(scoring.improvement_weight)
        * (i128::from(facts[selected].v) - i128::from(facts[0].v))
        - i128::from(scoring.refusal_weight) * refusals
        - i128::from(scoring.spent_weight) * spent;
    i128::from(return_value) == expected_return
}

#[cfg(feature = "semantic-policy")]
fn task_candidate_better(
    priority_levels: &[SemanticTaskPriorityLevel],
    facts: &[SemanticTaskFacts; 3],
    candidate: usize,
    incumbent: usize,
) -> bool {
    for level in priority_levels {
        let score = |slot: usize| -> i64 {
            level
                .goals
                .iter()
                .map(|goal| {
                    let query = usize::from(goal.query);
                    let target = u64::from(goal.target_truth);
                    let achieved = i64::from(facts[slot].truth[query] == target);
                    let base = i64::from(facts[0].truth[query] == target);
                    i64::from(goal.weight) * (achieved - base)
                })
                .sum()
        };
        let candidate_score = score(candidate);
        let incumbent_score = score(incumbent);
        if candidate_score != incumbent_score {
            return candidate_score > incumbent_score;
        }
    }
    facts[candidate].g > facts[incumbent].g
        || (facts[candidate].g == facts[incumbent].g && facts[candidate].c < facts[incumbent].c)
}

/// Three ordered query selections for the bounded transition ABI. Predicate,
/// arguments, observer program, eligibility, and scoring are application inputs.
/// This specification carries no authority; only the application controller may
/// attach an authorized task to its retained semantic session.
#[derive(Clone, Debug)]
pub struct SemanticTaskEvaluationSpec {
    /// Original statement records in the retained admission, in observer order.
    pub statement_records: [u32; 3],
    /// Admitted support records, each retaining its original statement association.
    pub allowed_support_records: Vec<u32>,
    pub program: Arc<dyn SemanticTaskProgram>,
    pub scoring: SemanticTaskScoring,
    /// Ordered, task-local lexicographic levels; an explicit empty list leaves
    /// predictive agreement and measured cost as the selection cascade.
    pub priority_levels: Vec<SemanticTaskPriorityLevel>,
    /// Bit n permits Truth4 value n for the corresponding candidate query.
    pub admissible_truth_masks: [u8; 3],
    /// Application-owned ex-ante decision that this episode may contribute an
    /// actor term. It is frozen with the task before any action draw.
    pub actor_eligible: bool,
    /// Original sealed inputs and complete loader geometry, fixed before draw.
    /// None denotes a task with no prospective training arena, not a fallback
    /// domain: subsequent training admission requires an original Some binding.
    pub training_domain: Option<SemanticTrainingDomain>,
}

/// Owner-validated cold read coverage for a task's queried semantic heads.
/// These records grant no use or mutation rights and are not current device
/// query receipts. Runtime feedback must still establish its actual live view.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticTaskObservationRoots {
    /// Logical root whose canonical insertion material was inspected.
    pub root_digest: Identity256,
    pub root_extents: [u32; 3],
    /// Original admitted query selections, retaining their order.
    pub query_records: [u32; 3],
    /// Query ordinal, genuine original insertion target (absent for a derived
    /// target), and original support record. Ordered by query, then insertion.
    /// A matching query value never supplies an absent original target.
    pub contributors: Vec<(u32, Option<u32>, u32)>,
}

/// Native seal of the independently validated goal authority carried by the
/// controller. The semantic root is the exact XLOG root inspected for the task;
/// the remaining roots bind the complete mandatory dependency and constraint
/// closures. These values are derived by the trusted controller after its
/// closure checks, never supplied by the model-update consumer.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticTaskGoalWitness {
    pub semantic_root: Identity256,
    pub authority_root: Identity256,
    pub mandatory_links_root: Identity256,
    pub constraints_root: Identity256,
    pub mandatory_link_count: u64,
    pub constraint_count: u64,
}

impl SemanticTaskEvaluationSpec {
    fn validate_records(
        &self,
        records: &SemanticAdmissionRecords,
    ) -> Result<(), SemanticTransitionError> {
        let invalid = |detail: &str| SemanticTransitionError::InvalidInput {
            detail: format!("task binding: {detail}"),
        };
        self.scoring
            .validate(self.program.editable_program().is_some())?;
        if let Some(domain) = &self.training_domain {
            domain.validate()?;
        }
        if self.priority_levels.len() > 3 {
            return Err(invalid("task priorities exceed the three-query bank"));
        }
        let mut seen_queries = [false; 3];
        let mut goal_count = 0usize;
        for level in &self.priority_levels {
            if level.goals.is_empty() {
                return Err(invalid("task priority level must contain a goal"));
            }
            goal_count += level.goals.len();
            if goal_count > 3 {
                return Err(invalid("task priorities exceed the three-query bank"));
            }
            for goal in &level.goals {
                let query = usize::from(goal.query);
                if query >= 3 || goal.target_truth > 3 || goal.weight == 0 {
                    return Err(invalid(
                        "task priority goal has invalid query, truth or weight",
                    ));
                }
                if std::mem::replace(&mut seen_queries[query], true) {
                    return Err(invalid("task priority query appears more than once"));
                }
                if self.admissible_truth_masks[query] & (1 << goal.target_truth) == 0 {
                    return Err(invalid(
                        "task priority target is forbidden by hard truth mask",
                    ));
                }
            }
        }
        if self
            .admissible_truth_masks
            .iter()
            .any(|mask| *mask == 0 || *mask & !15 != 0)
        {
            return Err(invalid(
                "truth eligibility requires a nonempty four-valued mask",
            ));
        }
        for index in self.statement_records {
            let record = records
                .records
                .get(index as usize)
                .ok_or_else(|| invalid("query statement is outside the admission"))?;
            let predicate = records
                .predicates
                .iter()
                .find(|predicate| predicate.predicate == record.predicate)
                .ok_or_else(|| invalid("query predicate is outside the admission"))?;
            if predicate.role != SemanticRecordRole::Statement {
                return Err(invalid("query selection is not a statement"));
            }
        }
        if self.allowed_support_records.len() > records.supports.len() {
            return Err(invalid(
                "support selections exceed the admitted support bank",
            ));
        }
        for &index in &self.allowed_support_records {
            let support = records
                .supports
                .get(index as usize)
                .ok_or_else(|| invalid("support selection is outside the admission"))?;
            if !self.statement_records.contains(&support.statement) {
                return Err(invalid(
                    "support belongs to a statement outside the task scope",
                ));
            }
        }
        Ok(())
    }
}

fn feedback_statement_payload(
    records: &SemanticAdmissionRecords,
    encoded: &[crate::semantic_hypergraph::SemanticRecordEncoding],
    record: u32,
) -> Result<Vec<u8>, SemanticTransitionError> {
    let statement = records
        .records
        .get(record as usize)
        .ok_or(SemanticTransitionError::InvalidTaskBank)?;
    let mut payload = Vec::new();
    let append = |payload: &mut Vec<u8>, index: u32| -> Result<(), SemanticTransitionError> {
        let atom = encoded
            .get(index as usize)
            .ok_or(SemanticTransitionError::InvalidTaskBank)?;
        // Canonical admission retains exact argument ranges. The predicate and
        // arity occupy the eight bytes immediately before the first argument;
        // zero-argument atoms end immediately after those same two u32 values.
        // No symbol lookup, numeric conversion, domain or digest enters features.
        let argument_begin = atom
            .arguments
            .first()
            .map_or(atom.bytes.len(), |range| range.start);
        let value_begin = argument_begin
            .checked_sub(8)
            .ok_or(SemanticTransitionError::InvalidTaskBank)?;
        let values = atom
            .bytes
            .get(value_begin..)
            .ok_or(SemanticTransitionError::InvalidTaskBank)?;
        payload.extend_from_slice(&(values.len() as u64).to_le_bytes());
        payload.extend_from_slice(values);
        Ok(())
    };
    append(&mut payload, record)?;
    let qualifier_count = u32::try_from(statement.qualifiers.len())
        .map_err(|_| SemanticTransitionError::InvalidTaskBank)?;
    payload.extend_from_slice(&qualifier_count.to_le_bytes());
    for &qualifier in &statement.qualifiers {
        append(&mut payload, qualifier)?;
    }
    Ok(payload)
}

/// Immutable native task content, separate from the controller's authority and
/// from every operand visible to the proposal policy.
pub(crate) struct TaskEvaluationBinding {
    admission_identity: Identity256,
    schema_generation: Identity256,
    spec: SemanticTaskEvaluationSpec,
    statements: [crate::SemanticStatementKey; 3],
    statement_bytes: BTreeMap<u32, Vec<u8>>,
    allowed_supports: Vec<(u32, [u8; 32])>,
    observation: SemanticTaskObservation,
    goal_witness: Option<SemanticTaskGoalWitness>,
    objective_law: SemanticTaskObjectiveLaw,
}

type TaskContentSelection = (
    [crate::SemanticStatementKey; 3],
    BTreeMap<u32, Vec<u8>>,
    Vec<(u32, [u8; 32])>,
);

fn task_content_selection(
    admission: &SemanticAdmission,
    statement_records: [u32; 3],
    allowed_support_records: &[u32],
) -> Result<TaskContentSelection, SemanticTransitionError> {
    let statements = statement_records.map(|record| {
        admission
            .statement_key(record)
            .map_err(SemanticTransitionError::Semantic)
    });
    let statements = statements.into_iter().collect::<Result<Vec<_>, _>>()?;
    let statements: [_; 3] = statements
        .try_into()
        .expect("three selected task statements");
    let mut statement_bytes = BTreeMap::new();
    for record in statement_records {
        statement_bytes.insert(
            record,
            feedback_statement_payload(admission.records(), &admission.encoded_records, record)?,
        );
    }
    let mut allowed_supports = BTreeSet::new();
    for &index in allowed_support_records {
        let record = admission
            .records()
            .supports
            .get(index as usize)
            .ok_or(SemanticTransitionError::InvalidTaskBank)?;
        if !statement_records.contains(&record.statement) {
            return Err(SemanticTransitionError::InvalidTaskBank);
        }
        let statement = admission
            .statement_key(record.statement)
            .map_err(SemanticTransitionError::Semantic)?;
        let event = admission
            .support_event(index)
            .map_err(SemanticTransitionError::Semantic)?;
        allowed_supports.insert((index, *event.identity(statement.identity()).as_bytes()));
    }
    Ok((
        statements,
        statement_bytes,
        allowed_supports.into_iter().collect(),
    ))
}

#[expect(
    clippy::too_many_arguments,
    reason = "task content identity binds independent admitted and observed materials"
)]
fn task_content_identity(
    admission_identity: Identity256,
    schema_generation: Identity256,
    statement_records: [u32; 3],
    statements: [crate::SemanticStatementKey; 3],
    statement_bytes: &BTreeMap<u32, Vec<u8>>,
    allowed_supports: &[(u32, [u8; 32])],
    observation: &SemanticTaskObservation,
    editable: Option<&crate::SemanticProgramAdmission>,
) -> SemanticTaskContentIdentity {
    let append_bytes = |hash: &mut Sha256, bytes: &[u8]| {
        hash.update((bytes.len() as u64).to_le_bytes());
        hash.update(bytes);
    };

    let mut query = Sha256::new();
    query.update(b"xlog.semantic.task-query.v1\0");
    query.update((statement_records.len() as u64).to_le_bytes());
    for (record, statement) in statement_records.into_iter().zip(statements) {
        query.update(record.to_le_bytes());
        query.update(statement.identity().as_bytes());
        append_bytes(
            &mut query,
            statement_bytes
                .get(&record)
                .expect("bound query statement retains canonical bytes"),
        );
    }
    append_bytes(&mut query, &observation.input_bytes);
    let query = Identity256::from_bytes(query.finalize().into());

    let mut theory_program = Sha256::new();
    theory_program.update(b"xlog.semantic.task-theory-program.v1\0");
    theory_program.update(admission_identity.as_bytes());
    theory_program.update(schema_generation.as_bytes());
    theory_program.update((allowed_supports.len() as u64).to_le_bytes());
    for (record, support) in allowed_supports {
        theory_program.update(record.to_le_bytes());
        theory_program.update(support);
    }
    append_bytes(&mut theory_program, &observation.program_source);
    if let Some(editable) = editable {
        theory_program.update(b"xlog.semantic.editable-program.v1\0");
        for word in editable.words() {
            theory_program.update(word.to_le_bytes());
        }
    }
    let theory_program = Identity256::from_bytes(theory_program.finalize().into());

    let mut result = Sha256::new();
    result.update(b"xlog.semantic.task-four-valued-result.v1\0");
    result.update(query.as_bytes());
    result.update(theory_program.as_bytes());
    append_bytes(&mut result, &observation.result_bytes);
    for truth in observation.expected_truth {
        result.update((truth as u64).to_le_bytes());
    }

    SemanticTaskContentIdentity {
        query,
        theory_program,
        result: Identity256::from_bytes(result.finalize().into()),
    }
}

impl TaskEvaluationBinding {
    pub(crate) fn bind(
        admission: &SemanticAdmission,
        spec: SemanticTaskEvaluationSpec,
        observation: SemanticTaskObservation,
    ) -> Result<Self, SemanticTransitionError> {
        spec.validate_records(admission.records())?;
        if let Some(program) = spec.program.editable_program() {
            program
                .validate()
                .map_err(|detail| SemanticTransitionError::InvalidInput {
                    detail: format!("task binding: {detail}"),
                })?;
        }
        let (statements, statement_bytes, allowed_supports) = task_content_selection(
            admission,
            spec.statement_records,
            &spec.allowed_support_records,
        )?;
        if observation.program_source.is_empty() || observation.result_bytes.is_empty() {
            return Err(publication_input_error(
                "native task observer omitted source or result custody",
            ));
        }
        let objective_law = spec
            .scoring
            .objective_law(spec.program.editable_program().is_some())?;
        Ok(Self {
            admission_identity: admission.identity(),
            schema_generation: admission.schema_generation(),
            spec,
            statements,
            statement_bytes,
            allowed_supports,
            observation,
            goal_witness: None,
            objective_law,
        })
    }

    pub(crate) fn identity(&self) -> Identity256 {
        let mut hash = Sha256::new();
        hash.update(if self.spec.program.editable_program().is_some() {
            b"xlog.semantic.task-evaluation.v12\0".as_slice()
        } else {
            b"xlog.semantic.task-evaluation.v11\0".as_slice()
        });
        hash.update(self.admission_identity.as_bytes());
        hash.update(self.schema_generation.as_bytes());
        // Keep source occurrence and explicit selection order separate from
        // the distinct original support records consumed by the device policy.
        hash.update((self.spec.statement_records.len() as u64).to_le_bytes());
        for index in self.spec.statement_records {
            hash.update(index.to_le_bytes());
        }
        hash.update((self.spec.allowed_support_records.len() as u64).to_le_bytes());
        for index in &self.spec.allowed_support_records {
            hash.update(index.to_le_bytes());
        }
        hash.update((self.observation.program_source.len() as u64).to_le_bytes());
        hash.update(&self.observation.program_source);
        hash.update((self.observation.input_bytes.len() as u64).to_le_bytes());
        hash.update(&self.observation.input_bytes);
        hash.update((self.observation.result_bytes.len() as u64).to_le_bytes());
        hash.update(&self.observation.result_bytes);
        for truth in self.observation.expected_truth {
            hash.update((truth as u64).to_le_bytes());
        }
        hash.update(self.spec.admissible_truth_masks);
        hash.update([u8::from(self.spec.actor_eligible)]);
        for weight in self.spec.scoring.words() {
            hash.update(weight.to_le_bytes());
        }
        // Checkpoint task/scoring identities retain these cold numerical bits.
        // Restore must reproduce them before an arena or publication is usable.
        hash.update(self.objective_law.evaluator_min.to_bits().to_le_bytes());
        hash.update(self.objective_law.evaluator_max.to_bits().to_le_bytes());
        for coefficient in self.objective_law.coefficients {
            hash.update(coefficient.to_bits().to_le_bytes());
        }
        hash.update(self.objective_law.structural_cost.unit.as_bytes());
        hash.update(self.objective_law.structural_cost.cap.to_le_bytes());
        hash.update([u8::from(self.spec.training_domain.is_some())]);
        if let Some(domain) = &self.spec.training_domain {
            hash.update(domain.identity().as_bytes());
        }
        hash.update(b"xlog.semantic.task-priorities.v1\0");
        hash.update((self.spec.priority_levels.len() as u64).to_le_bytes());
        for level in &self.spec.priority_levels {
            hash.update((level.goals.len() as u64).to_le_bytes());
            for goal in &level.goals {
                hash.update([goal.query, goal.target_truth]);
                hash.update(goal.weight.to_le_bytes());
            }
        }
        if let Some(editable) = self.spec.program.editable_program() {
            hash.update(b"xlog.semantic.editable-program.v1\0");
            for word in editable.words() {
                hash.update(word.to_le_bytes());
            }
        }
        for statement in self.statements {
            hash.update(statement.identity().as_bytes());
        }
        hash.update((self.allowed_supports.len() as u64).to_le_bytes());
        for (record, support) in &self.allowed_supports {
            hash.update(record.to_le_bytes());
            hash.update(support);
        }
        if let Some(witness) = self.goal_witness {
            hash.update(b"xlog.semantic.goal-witness.v1\0");
            hash.update(witness.semantic_root.as_bytes());
            hash.update(witness.authority_root.as_bytes());
            hash.update(witness.mandatory_links_root.as_bytes());
            hash.update(witness.constraints_root.as_bytes());
            hash.update(witness.mandatory_link_count.to_le_bytes());
            hash.update(witness.constraint_count.to_le_bytes());
        }
        Identity256::from_bytes(hash.finalize().into())
    }

    pub(crate) fn content_identity(&self) -> SemanticTaskContentIdentity {
        task_content_identity(
            self.admission_identity,
            self.schema_generation,
            self.spec.statement_records,
            self.statements,
            &self.statement_bytes,
            &self.allowed_supports,
            &self.observation,
            self.spec.program.editable_program(),
        )
    }

    pub(crate) fn cold_content(
        admission: &SemanticAdmission,
        statement_records: [u32; 3],
        allowed_support_records: &[u32],
        editable: Option<&crate::SemanticProgramAdmission>,
        observation: SemanticTaskObservation,
    ) -> Result<(SemanticTaskContentIdentity, [crate::SemanticTruth; 3]), SemanticTransitionError>
    {
        if observation.program_source.is_empty() || observation.result_bytes.is_empty() {
            return Err(publication_input_error(
                "native task observer omitted source or result custody",
            ));
        }
        if let Some(program) = editable {
            program
                .validate()
                .map_err(|detail| SemanticTransitionError::InvalidInput {
                    detail: format!("task binding: {detail}"),
                })?;
        }
        let (statements, statement_bytes, allowed_supports) =
            task_content_selection(admission, statement_records, allowed_support_records)?;
        let content = task_content_identity(
            admission.identity(),
            admission.schema_generation(),
            statement_records,
            statements,
            &statement_bytes,
            &allowed_supports,
            &observation,
            editable,
        );
        Ok((content, observation.expected_truth))
    }

    pub(crate) fn expected_truth(&self) -> [crate::SemanticTruth; 3] {
        self.observation.expected_truth
    }

    #[cfg(feature = "semantic-policy")]
    fn goal_witness(&self) -> Option<SemanticTaskGoalWitness> {
        self.goal_witness
    }

    pub(crate) fn content(&self) -> (SemanticTaskContentIdentity, [crate::SemanticTruth; 3]) {
        (self.content_identity(), self.expected_truth())
    }

    #[cfg(feature = "semantic-policy")]
    fn completed_result_material(&self) -> SemanticCompletedStepWitnessMaterial {
        let identities = self.content_identity();
        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"xlog.semantic.task-four-valued-result.v1\0");
        bytes.extend_from_slice(identities.query.as_bytes());
        bytes.extend_from_slice(identities.theory_program.as_bytes());
        material_u64(&mut bytes, self.observation.result_bytes.len() as u64);
        bytes.extend_from_slice(&self.observation.result_bytes);
        for truth in self.observation.expected_truth {
            material_u64(&mut bytes, truth as u64);
        }
        SemanticCompletedStepWitnessMaterial {
            identity: identities.result,
            bytes,
        }
    }

    pub(crate) fn spec(&self) -> &SemanticTaskEvaluationSpec {
        &self.spec
    }

    pub(crate) fn priority_levels(&self) -> &[SemanticTaskPriorityLevel] {
        &self.spec.priority_levels
    }

    pub(crate) fn words(&self, owner: u64) -> Vec<u64> {
        let mut words = vec![6, owner];
        words.extend(identity_words(*self.identity().as_bytes()));
        for statement in self.statements {
            words.extend(identity_words(*statement.identity().as_bytes()));
        }
        words.extend(self.observation.expected_truth.map(|truth| truth as u64));
        words.push(self.allowed_supports.len() as u64);
        words.extend(self.spec.statement_records.map(u64::from));
        words.extend(self.spec.scoring.words());
        words.extend(self.spec.admissible_truth_masks.map(u64::from));
        for (record, support) in &self.allowed_supports {
            words.push(u64::from(*record));
            words.extend(identity_words(*support));
        }
        if let Some(witness) = self.goal_witness {
            words.extend(identity_words(*witness.semantic_root.as_bytes()));
            words.extend(identity_words(*witness.authority_root.as_bytes()));
            words.extend(identity_words(*witness.mandatory_links_root.as_bytes()));
            words.extend(identity_words(*witness.constraints_root.as_bytes()));
            words.push(witness.mandatory_link_count);
            words.push(witness.constraint_count);
        } else {
            words.extend([0; 18]);
        }
        words.push(u64::from(self.spec.actor_eligible));
        words.push(self.spec.priority_levels.len() as u64);
        for level in self.spec.priority_levels.iter().take(3) {
            words.push(level.goals.len() as u64);
        }
        words.resize(words.len() + 3 - self.spec.priority_levels.len(), 0);
        let mut goals = 0;
        for level in &self.spec.priority_levels {
            for goal in &level.goals {
                words.extend([
                    u64::from(goal.query),
                    u64::from(goal.target_truth),
                    u64::from(goal.weight),
                ]);
                goals += 1;
            }
        }
        words.resize(words.len() + (3 - goals) * 3, 0);
        if let Some(editable) = self.spec.program.editable_program() {
            let bank = editable.words();
            words.extend([1, bank.len() as u64]);
            words.extend(bank);
        }
        words
    }
}

/// One row of the generated roster. Text fields are text positions; edit fields
/// index the eighteen-field action signature. Offsets count input elements.
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticComponent {
    pub offset: u64,
    pub ordinal: u32,
    pub lane: u32,
    pub slot: u32,
    pub field: u32,
    pub kind: u32,
    pub cardinality: u32,
}

impl SemanticComponent {
    pub const fn is_text(&self) -> bool {
        self.kind == COMPONENT_KIND_TEXT as u32
    }
}

/// Field codebook role and NULL-only cold cardinality in this catalogue.
pub struct SemanticCatalogueField {
    pub ordinal: u32,
    pub cardinality: u32,
    pub name: &'static str,
    pub role: &'static str,
}

/// Declarative action/opcode signature, including dependent opcode selection.
pub struct SemanticCatalogueSignature {
    pub value: u32,
    pub kind: &'static str,
    pub name: &'static str,
    pub signature: &'static str,
}

include!(concat!(
    env!("OUT_DIR"),
    "/semantic_transition_catalogue.rs"
));

pub const SEMANTIC_TRANSITION_GENERATION: u64 = CATALOGUE_GENERATION;
pub const SEMANTIC_TRANSITION_COMPONENT_COUNT: usize = COMPONENT_COUNT;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticCatalogueBinding {
    pub generation: u64,
    pub digest: Identity256,
}

/// The sole built-in action law; both Rust and CUDA are generated from its declaration.
pub struct SemanticActionCatalogue;

impl SemanticActionCatalogue {
    pub const fn current() -> Self {
        Self
    }
    pub const fn binding(&self) -> SemanticCatalogueBinding {
        SemanticCatalogueBinding {
            generation: CATALOGUE_GENERATION,
            digest: Identity256::from_bytes(CATALOGUE_DIGEST),
        }
    }
    pub const fn canonical_bytes(&self) -> &'static [u8] {
        CATALOGUE_ENCODING
    }
    #[cfg(feature = "semantic-policy")]
    fn completed_material(&self) -> SemanticCompletedStepWitnessMaterial {
        SemanticCompletedStepWitnessMaterial {
            identity: self.binding().digest,
            bytes: self.canonical_bytes().to_vec(),
        }
    }
    pub const fn components(&self) -> &'static [SemanticComponent] {
        COMPONENTS
    }
    pub const fn fields(&self) -> &'static [SemanticCatalogueField] {
        CATALOGUE_FIELDS
    }
    pub const fn signatures(&self) -> &'static [SemanticCatalogueSignature] {
        CATALOGUE_SIGNATURES
    }
    pub const fn text_cardinality(&self) -> usize {
        TEXT_CARDINALITY
    }
    pub const fn scratch_bytes(&self) -> usize {
        SCRATCH_BYTES
    }
    /// (active fields, forced-NULL fields) for NO_EDIT, INSERT_SUPPORT and INSERT_RULE.
    pub const fn field_masks(&self) -> [(u32, u32); 3] {
        [
            (NO_EDIT_ACTIVE_MASK as u32, NO_EDIT_NULL_MASK as u32),
            (
                INSERT_SUPPORT_ACTIVE_MASK as u32,
                INSERT_SUPPORT_NULL_MASK as u32,
            ),
            (INSERT_RULE_ACTIVE_MASK as u32, INSERT_RULE_NULL_MASK as u32),
        ]
    }
}

/// Cold-bound FP32 logits and binary product support in original category order.
pub struct SemanticComponentInput {
    pub logits: Vec<f32>,
    pub product_support: Vec<u8>,
}

/// FP32 element ranges for one field in the native policy parameter snapshot.
/// NULL is a category, but has no stored embedding row. The action-class field
/// has no NULL: its category zero is the trainable no-edit action.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticPolicyFieldLayout {
    pub embeddings: std::ops::Range<usize>,
    pub biases: std::ops::Range<usize>,
    pub cardinality: usize,
    pub null_category: Option<usize>,
}

/// Packing of the immutable policy inputs consumed by the serial component loop.
/// These ranges describe storage, not authority to substitute a model generation.
/// A session derives the layout from its retained admission's actual codebooks.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticPolicyLayout {
    pub z: std::ops::Range<usize>,
    pub recurrence: std::ops::Range<usize>,
    pub positions: std::ops::Range<usize>,
    pub fields: Vec<SemanticPolicyFieldLayout>,
    pub parameter_cells: usize,
}

impl SemanticPolicyLayout {
    fn from_components(components: &[SemanticComponent]) -> Result<Self, SemanticTransitionError> {
        let invalid = || SemanticTransitionError::InvalidInput {
            detail: "policy layout requires the complete native component roster".into(),
        };
        if components.len() != COMPONENT_COUNT {
            return Err(invalid());
        }
        let z = 0usize..4 * 128;
        let recurrence = z.end..z.end + 128 * 128;
        let positions = recurrence.end..recurrence.end + 18 * 128;
        let mut cursor = positions.end;
        let mut fields = Vec::with_capacity(18);
        for field in 0..18 {
            let cardinality = components[32 + field].cardinality as usize;
            if cardinality == 0 {
                return Err(invalid());
            }
            for lane in 0..2 {
                for slot in 0..2 {
                    let component = components[lane * 68 + 32 + slot * 18 + field];
                    if component.kind != COMPONENT_KIND_EDIT as u32
                        || component.field as usize != field
                        || component.lane as usize != lane + 1
                        || component.slot as usize != slot
                        || component.cardinality as usize != cardinality
                    {
                        return Err(invalid());
                    }
                }
            }
            let null_category = (field != 0).then_some(0);
            let embedding_cells = (cardinality - usize::from(null_category.is_some()))
                .checked_mul(128)
                .ok_or_else(invalid)?;
            let end = cursor.checked_add(embedding_cells).ok_or_else(invalid)?;
            let embeddings = cursor..end;
            cursor = end;
            let bias_cells = if null_category.is_some() && cardinality == 1 {
                0
            } else {
                cardinality
            };
            let end = cursor.checked_add(bias_cells).ok_or_else(invalid)?;
            let biases = cursor..end;
            cursor = end;
            fields.push(SemanticPolicyFieldLayout {
                embeddings,
                biases,
                cardinality,
                null_category,
            });
        }
        Ok(Self {
            z,
            recurrence,
            positions,
            fields,
            parameter_cells: cursor,
        })
    }

    /// Both lanes retain the initial state and all thirty-six field successors.
    pub const fn recurrent_cells(&self) -> usize {
        2 * 37 * 128
    }

    /// The same score bank is reused serially by every structural component.
    pub fn score_cells(&self) -> usize {
        self.fields
            .iter()
            .map(|field| field.cardinality)
            .max()
            .unwrap_or(0)
    }

    #[cfg(feature = "semantic-policy")]
    fn retained_score_stride(&self) -> usize {
        self.fields.iter().map(|field| field.cardinality).sum()
    }

    #[cfg(feature = "semantic-policy")]
    fn retained_score_cells(&self) -> usize {
        4 * self.retained_score_stride()
    }
}

/// Immutable descriptor meanings derived from the graph's admitted records.
/// Category zero is NULL. Nonzero categories are sorted by logical typed bytes,
/// independent of arena slots and digests. Equal-valued support records retain
/// separate categories, ordered by their original admission index.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SemanticActionDescriptor {
    Target {
        predicate: xlog_core::RelId,
    },
    Operand {
        scalar_type: xlog_core::ScalarType,
        sort_label: String,
        encoded_value: Vec<u8>,
    },
    QualifierBundle {
        records: Vec<u32>,
    },
    SupportEvent {
        source_record: u32,
    },
    RulePredicate {
        predicate: u32,
    },
    RuleVariable {
        index: u32,
    },
}

#[cfg(feature = "semantic-policy")]
struct SemanticDecodedSupportInsertion {
    statement: SemanticStatementIdentity,
    support: SemanticSupportIdentity,
    source_event: u32,
    reconstruction: [u32; 10],
    bytes: Vec<u8>,
}

struct SemanticDecodedRuleInsertion {
    rule: crate::SemanticProgramRule,
    #[cfg(any(feature = "semantic-policy", test))]
    bytes: Vec<u8>,
}

fn semantic_program_rule_words(rule: crate::SemanticProgramRule) -> [u64; 10] {
    [
        rule.head_predicate,
        rule.left_predicate,
        rule.right_predicate,
        rule.body_count,
        rule.head_variables[0],
        rule.head_variables[1],
        rule.left_variables[0],
        rule.left_variables[1],
        rule.right_variables[0],
        rule.right_variables[1],
    ]
    .map(u64::from)
}

struct ActionCodebooks {
    words: Vec<u64>,
    targets: Vec<SemanticActionDescriptor>,
    operands: Vec<SemanticActionDescriptor>,
    qualifiers: Vec<SemanticActionDescriptor>,
    leaves: Vec<SemanticActionDescriptor>,
    components: Vec<SemanticComponent>,
    binding: SemanticCatalogueBinding,
    program_binding: Option<Identity256>,
    input_cells: usize,
}

impl ActionCodebooks {
    fn program_binding(program: &crate::SemanticProgramAdmission) -> Identity256 {
        let mut hash = Sha256::new();
        hash.update(b"xlog.semantic.rule-codebook.program.v1\0");
        for word in program.words() {
            hash.update(word.to_le_bytes());
        }
        Identity256::from_bytes(hash.finalize().into())
    }

    fn decoded_rule_insertion(
        &self,
        program: &crate::SemanticProgramAdmission,
        choices: &[u32; 18],
    ) -> Result<SemanticDecodedRuleInsertion, SemanticTransitionError> {
        if self.program_binding != Some(Self::program_binding(program))
            || choices[0] != 1
            || choices[1] != 2
            || choices[11..].iter().any(|&choice| choice != 0)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        fn chosen(
            entries: &[SemanticActionDescriptor],
            choice: u32,
        ) -> Result<&SemanticActionDescriptor, SemanticTransitionError> {
            choice
                .checked_sub(1)
                .and_then(|index| entries.get(index as usize))
                .ok_or(SemanticTransitionError::ObservationMismatch)
        }
        let predicate = |entry: &SemanticActionDescriptor| match entry {
            SemanticActionDescriptor::RulePredicate { predicate }
                if *predicate < program.predicate_count =>
            {
                Ok(*predicate)
            }
            _ => Err(SemanticTransitionError::ObservationMismatch),
        };
        let variable = |entry: &SemanticActionDescriptor| match entry {
            SemanticActionDescriptor::RuleVariable { index } if *index < 4 => Ok(*index),
            _ => Err(SemanticTransitionError::ObservationMismatch),
        };
        let rule = crate::SemanticProgramRule {
            head_predicate: predicate(chosen(&self.targets, choices[2])?)?,
            left_predicate: predicate(chosen(&self.operands, choices[3])?)?,
            right_predicate: predicate(chosen(&self.operands, choices[4])?)?,
            body_count: 2,
            head_variables: [
                variable(chosen(&self.operands, choices[5])?)?,
                variable(chosen(&self.operands, choices[6])?)?,
            ],
            left_variables: [
                variable(chosen(&self.operands, choices[7])?)?,
                variable(chosen(&self.operands, choices[8])?)?,
            ],
            right_variables: [
                variable(chosen(&self.operands, choices[9])?)?,
                variable(chosen(&self.operands, choices[10])?)?,
            ],
        };
        let bound = rule
            .left_variables
            .into_iter()
            .chain(rule.right_variables)
            .fold(0u8, |set, index| set | (1 << index));
        if rule
            .head_variables
            .iter()
            .any(|index| bound & (1 << index) == 0)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        #[cfg(any(feature = "semantic-policy", test))]
        let bytes = {
            let mut bytes = Vec::new();
            bytes.extend_from_slice(b"XLOG-DECODED-RULE-INSERTION\0");
            material_u64(&mut bytes, 1);
            bytes.extend_from_slice(self.binding.digest.as_bytes());
            bytes.extend_from_slice(Self::program_binding(program).as_bytes());
            for &choice in choices {
                material_u32(&mut bytes, choice);
            }
            for field in semantic_program_rule_words(rule) {
                material_u32(&mut bytes, field as u32);
            }
            bytes
        };
        Ok(SemanticDecodedRuleInsertion {
            rule,
            #[cfg(any(feature = "semantic-policy", test))]
            bytes,
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn decoded_support_insertion(
        &self,
        admission: &SemanticAdmission,
        choices: &[u32; 18],
    ) -> Result<Option<SemanticDecodedSupportInsertion>, SemanticTransitionError> {
        if choices[0] == 0 {
            return Ok(None);
        }
        if choices[0] != 1 || choices[1] != 1 {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let chosen = |count: usize, choice: u32| {
            usize::try_from(choice)
                .ok()
                .and_then(|choice| choice.checked_sub(1))
                .filter(|&index| index < count)
                .ok_or(SemanticTransitionError::ObservationMismatch)
        };
        let target = chosen(self.targets.len(), choices[2])?;
        let predicate = match self.targets[target] {
            SemanticActionDescriptor::Target { predicate } => predicate,
            _ => return Err(SemanticTransitionError::ObservationMismatch),
        };
        let arity = admission
            .records()
            .predicates
            .iter()
            .find(|entry| entry.predicate == predicate)
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .schema
            .arity();
        let mut reconstruction = [0u32; 10];
        reconstruction[0] = predicate.0;
        for argument in 0..arity {
            let choice = choices[3 + argument];
            chosen(self.operands.len(), choice)?;
            let offset = self.words[2] as usize + 6 * choice as usize;
            reconstruction[1 + 2 * argument] = self.words[offset + 4] as u32;
            reconstruction[2 + 2 * argument] = self.words[offset + 5] as u32;
        }
        let qualifier = choices[11];
        chosen(self.qualifiers.len(), qualifier)?;
        reconstruction[9] = self.words[self.words[4] as usize + 3 * qualifier as usize + 2] as u32;
        let leaf = chosen(self.leaves.len(), choices[17])?;
        let source_event = match self.leaves[leaf] {
            SemanticActionDescriptor::SupportEvent { source_record } => source_record,
            _ => return Err(SemanticTransitionError::ObservationMismatch),
        };
        let statement = material_statement_key(admission, None, &reconstruction)
            .map_err(SemanticTransitionError::Semantic)?
            .identity();
        let support = admission
            .support_event(source_event)
            .map_err(SemanticTransitionError::Semantic)?
            .identity(statement);
        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-DECODED-SUPPORT-INSERTION\0");
        material_u64(&mut bytes, 1);
        bytes.extend_from_slice(self.binding.digest.as_bytes());
        for &choice in choices {
            material_u32(&mut bytes, choice);
        }
        bytes.extend_from_slice(statement.as_bytes());
        bytes.extend_from_slice(support.as_bytes());
        material_u32(&mut bytes, source_event);
        for reference in reconstruction {
            material_u32(&mut bytes, reference);
        }
        Ok(Some(SemanticDecodedSupportInsertion {
            statement,
            support,
            source_event,
            reconstruction,
            bytes,
        }))
    }

    #[cfg(feature = "semantic-policy")]
    fn completed_material(&self) -> SemanticCompletedStepWitnessMaterial {
        SemanticCompletedStepWitnessMaterial {
            identity: self.binding.digest,
            bytes: publication_abi_bytes(&self.words),
        }
    }

    #[cfg(feature = "semantic-policy")]
    fn completed_roster_material(&self) -> SemanticCompletedStepWitnessMaterial {
        let mut bytes = Vec::with_capacity(
            b"xlog.semantic-action-roster.v1\0".len() + 32 + 8 + self.components.len() * 7 * 8,
        );
        bytes.extend_from_slice(b"xlog.semantic-action-roster.v1\0");
        bytes.extend_from_slice(self.binding.digest.as_bytes());
        material_u64(&mut bytes, self.components.len() as u64);
        for component in &self.components {
            for value in [
                component.offset,
                component.ordinal as u64,
                component.lane as u64,
                component.slot as u64,
                component.field as u64,
                component.kind as u64,
                component.cardinality as u64,
            ] {
                material_u64(&mut bytes, value);
            }
        }
        SemanticCompletedStepWitnessMaterial {
            identity: Identity256::from_bytes(Sha256::digest(&bytes).into()),
            bytes,
        }
    }

    fn support_layout(&self) -> (Vec<std::ops::Range<usize>>, usize) {
        (
            self.components
                .iter()
                .map(|component| {
                    component.offset as usize
                        ..component.offset as usize + component.cardinality as usize
                })
                .collect(),
            self.input_cells,
        )
    }

    fn derive(
        admission: &SemanticAdmission,
        owner: u64,
        program: Option<&crate::SemanticProgramAdmission>,
    ) -> Result<Self, SemanticTransitionError> {
        if let Some(program) = program {
            program
                .validate()
                .map_err(|detail| SemanticTransitionError::InvalidInput {
                    detail: detail.into(),
                })?;
        }
        let records = admission.records();
        let predicates: BTreeMap<_, _> = records
            .predicates
            .iter()
            .map(|p| (p.predicate.0, p))
            .collect();
        let sorts: BTreeSet<_> = records
            .predicates
            .iter()
            .flat_map(|p| p.schema.sort_labels().iter().cloned())
            .collect();
        let sorts: BTreeMap<_, _> = sorts
            .into_iter()
            .enumerate()
            .map(|(i, s)| (s, i as u64 + 1))
            .collect();
        let mut targets = BTreeMap::new();
        for p in predicates
            .values()
            .filter(|p| p.role == SemanticRecordRole::Statement && p.schema.arity() <= 4)
        {
            let mut row = vec![p.predicate.0 as u64, p.schema.arity() as u64];
            row.extend((0..4).map(|i| {
                p.schema
                    .columns
                    .get(i)
                    .map_or(0, |(_, t)| t.to_code() as u64 + 1)
            }));
            row.extend((0..4).map(|i| p.schema.sort_labels().get(i).map_or(0, |s| sorts[s])));
            targets.insert(
                p.predicate.0.to_le_bytes(),
                (
                    row,
                    SemanticActionDescriptor::Target {
                        predicate: p.predicate,
                    },
                ),
            );
        }
        let mut operands = BTreeMap::new();
        for (record_index, (record, encoded)) in records
            .records
            .iter()
            .zip(&admission.encoded_records)
            .enumerate()
        {
            let schema = &predicates[&record.predicate.0].schema;
            for (i, range) in encoded.arguments.iter().enumerate() {
                let value = encoded.bytes[range.clone()].to_vec();
                let label = &schema.sort_labels()[i];
                let mut key = value.clone();
                key.extend_from_slice(&(label.len() as u64).to_le_bytes());
                key.extend_from_slice(label.as_bytes());
                operands.entry(key).or_insert_with(|| {
                    (
                        value.clone(),
                        schema.columns[i].1.to_code() as u64 + 1,
                        sorts[label],
                        record_index as u64,
                        i as u64,
                        SemanticActionDescriptor::Operand {
                            scalar_type: schema.columns[i].1,
                            sort_label: label.clone(),
                            encoded_value: value,
                        },
                    )
                });
            }
        }
        let logical = |indices: &[u32]| {
            let mut bytes = (indices.len() as u32).to_le_bytes().to_vec();
            for &index in indices {
                let atom = &admission.encoded_records[index as usize].bytes;
                bytes.extend_from_slice(&(atom.len() as u64).to_le_bytes());
                bytes.extend_from_slice(atom);
            }
            bytes
        };
        let mut qualifiers = BTreeMap::new();
        qualifiers.insert(logical(&[]), (Vec::new(), u32::MAX));
        for (index, record) in records.records.iter().enumerate() {
            if predicates[&record.predicate.0].role == SemanticRecordRole::Statement {
                qualifiers
                    .entry(logical(&record.qualifiers))
                    .or_insert_with(|| (record.qualifiers.clone(), index as u32));
            }
        }
        let mut leaves = BTreeMap::new();
        for (index, support) in records.supports.iter().enumerate() {
            let polarity = match support.polarity {
                crate::SemanticPolarity::Pro => 1u64,
                crate::SemanticPolarity::Contra => 2,
            };
            let refs = [
                support.provenance,
                support.source,
                support.context,
                support.scope,
            ];
            let mut key = polarity.to_le_bytes().to_vec();
            key.extend(logical(&refs));
            let mut words = vec![polarity];
            for record in refs {
                words.extend(identity_words(
                    Sha256::digest(&admission.encoded_records[record as usize].bytes).into(),
                ));
            }
            words.push(index as u64);
            leaves.insert(
                (key, index),
                (
                    words,
                    SemanticActionDescriptor::SupportEvent {
                        source_record: index as u32,
                    },
                ),
            );
        }
        let additional_targets = program
            .map(|program| program.predicate_count as usize)
            .unwrap_or(0);
        let additional_operands = program
            .map(|program| program.predicate_count as usize + 4)
            .unwrap_or(0);
        if [
            targets.len().saturating_add(additional_targets),
            operands.len().saturating_add(additional_operands),
            qualifiers.len(),
            leaves.len(),
        ]
        .into_iter()
        .any(|n| n >= 65536)
        {
            return Err(SemanticTransitionError::InvalidInput {
                detail: "descriptor codebook exceeds 65535 non-NULL entries".into(),
            });
        }
        let mut words = vec![0; 25];
        let mut bytes = Vec::new();
        words[0] = words.len() as u64;
        words[1] = (targets.len() + additional_targets) as u64 + 1;
        words.extend([0; 10]);
        let mut target_views: Vec<SemanticActionDescriptor> = targets
            .into_values()
            .map(|(row, view)| {
                words.extend(row);
                view
            })
            .collect();
        if let Some(program) = program {
            for predicate in 0..program.predicate_count {
                words.extend([u64::from(predicate), u64::MAX, 0, 0, 0, 0, 0, 0, 0, 0]);
                target_views.push(SemanticActionDescriptor::RulePredicate { predicate });
            }
        }
        words[2] = words.len() as u64;
        words[3] = (operands.len() + additional_operands) as u64 + 1;
        words.extend([0; 6]);
        let mut operand_views: Vec<SemanticActionDescriptor> = operands
            .into_values()
            .map(|(value, ty, sort, record, argument, view)| {
                words.extend([
                    bytes.len() as u64,
                    value.len() as u64,
                    ty,
                    sort,
                    record,
                    argument,
                ]);
                bytes.extend(value);
                view
            })
            .collect();
        if let Some(program) = program {
            for predicate in 0..program.predicate_count {
                words.extend([0, 0, 0, 1, u64::from(predicate), 0]);
                operand_views.push(SemanticActionDescriptor::RulePredicate { predicate });
            }
            for index in 0..4 {
                words.extend([0, 0, 0, 2, u64::from(index), 0]);
                operand_views.push(SemanticActionDescriptor::RuleVariable { index });
            }
        }
        words[4] = words.len() as u64;
        words[5] = qualifiers.len() as u64 + 1;
        words.extend([0; 3]);
        let qualifier_views = qualifiers
            .into_values()
            .map(|(refs, source)| {
                let offset = bytes.len();
                bytes.extend_from_slice(&(refs.len() as u32).to_le_bytes());
                for &index in &refs {
                    bytes.extend_from_slice(&Sha256::digest(
                        &admission.encoded_records[index as usize].bytes,
                    ));
                }
                words.extend([
                    offset as u64,
                    (bytes.len() - offset) as u64,
                    u64::from(source),
                ]);
                SemanticActionDescriptor::QualifierBundle { records: refs }
            })
            .collect();
        words[6] = words.len() as u64;
        words[7] = leaves.len() as u64 + 1;
        words.extend([0; 18]);
        let leaf_views = leaves
            .into_values()
            .map(|(row, view)| {
                words.extend(row);
                view
            })
            .collect();
        words[8] = words.len() as u64 * 8;
        words[9] = bytes.len() as u64;
        words[10..14].copy_from_slice(&identity_words(*admission.schema_generation().as_bytes()));
        words[14] = owner;
        words[15] = admission.base().slot() as u64;
        words[16] = admission.base().generation();
        words[17..21].copy_from_slice(&identity_words(
            *admission.base_snapshot().digest().as_bytes(),
        ));
        bytes.resize(bytes.len().div_ceil(8) * 8, 0);
        words.extend(
            bytes
                .as_chunks::<8>()
                .0
                .iter()
                .map(|v| u64::from_le_bytes(*v)),
        );
        let mut hash = Sha256::new();
        hash.update(b"xlog.semantic.action-binding.v4\0");
        hash.update(CATALOGUE_DIGEST);
        hash.update(admission.identity().as_bytes());
        let program_binding = program.map(Self::program_binding);
        if let Some(identity) = program_binding {
            hash.update(identity.as_bytes());
        }
        for &word in &words {
            hash.update(word.to_le_bytes());
        }
        let digest = Identity256::from_bytes(hash.finalize().into());
        words[21..25].copy_from_slice(&identity_words(*digest.as_bytes()));
        let mut offset = 0u64;
        let components = COMPONENTS
            .iter()
            .map(|&c| {
                let cardinality = if c.is_text() {
                    c.cardinality
                } else {
                    match c.field {
                        2 => words[1] as u32,
                        3..=6 => words[3] as u32,
                        7..=10 if program.is_some() => words[3] as u32,
                        1 if program.is_none() => 2,
                        11 => words[5] as u32,
                        17 => words[7] as u32,
                        _ => c.cardinality,
                    }
                };
                let result = SemanticComponent {
                    offset,
                    cardinality,
                    ..c
                };
                offset += cardinality as u64;
                result
            })
            .collect();
        Ok(Self {
            words,
            targets: target_views,
            operands: operand_views,
            qualifiers: qualifier_views,
            leaves: leaf_views,
            components,
            binding: SemanticCatalogueBinding {
                generation: CATALOGUE_GENERATION,
                digest,
            },
            program_binding,
            input_cells: offset as usize,
        })
    }
}

fn identity_words(bytes: [u8; 32]) -> [u64; 4] {
    std::array::from_fn(|i| u64::from_le_bytes(bytes[8 * i..8 * i + 8].try_into().unwrap()))
}

// SAFETY: fixed C layout, integral fields only.
unsafe impl DeviceRepr for SemanticComponent {}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticRngBinding {
    pub model_generation: u32,
    pub stream_serial: u64,
    pub family_id: u8,
    pub proposal: u32,
}

/// Device-produced receipt. Integers use three little-endian 64-bit limbs.
/// The exact probability is p/q; the exact importance factor is
/// p/factor_denominator. Singleton rows canonically use 1/1 for both.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticTransitionReceipt {
    pub proposal: u64,
    pub catalogue_generation: u64,
    pub catalogue_digest: Identity256,
    /// Binds the retained admission, acquired base, owner and logical codebooks.
    pub admission_binding: Identity256,
    pub ordinal: u32,
    pub lane: u32,
    pub slot: u32,
    pub field: u32,
    pub kind: u32,
    pub choice: u32,
    pub legal_count: u32,
    pub active_count: u32,
    pub selected_rank: u32,
    pub reserved: u32,
    pub key: [u32; 2],
    pub counter: [u32; 4],
    pub random_words: [u32; 4],
    pub draw: u64,
    pub cdf_start: u64,
    pub cdf_end: u64,
    pub mass: u64,
    pub p: [u64; 3],
    pub q: [u64; 3],
    pub factor_denominator: [u64; 3],
    pub cumulative_mass_below: [u64; 3],
    pub active_fields: u32,
    pub null_fields: u32,
}

// SAFETY: C layout, integral fields only; all bit patterns are valid.
unsafe impl DeviceRepr for SemanticTransitionReceipt {}

fn canonical_text_null(receipt: &SemanticTransitionReceipt) -> bool {
    receipt.kind == COMPONENT_KIND_TEXT as u32
        && receipt.choice == TEXT_NULL as u32
        && receipt.legal_count == 1
        && receipt.active_count == 1
        && receipt.selected_rank == 0
        && receipt.cumulative_mass_below == [0, 0, 0]
        && receipt.active_fields == 0
        && receipt.null_fields == 0
        && receipt.p == [1, 0, 0]
        && receipt.q == [1, 0, 0]
        && receipt.factor_denominator == [1, 0, 0]
        && receipt.cdf_start == 0
        && receipt.cdf_end == 1 << 63
        && receipt.mass == 1 << 63
}

/// Device-computed facts, using the three actual canonical truth-query results.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticTaskFacts {
    /// Ordered actual Truth4 codes for the three task queries. A task-refused
    /// lane has no executed truth outcome; its terminal refusal is authoritative.
    pub truth: [u64; 3],
    /// Equality of each actual Truth4 answer to the protected observer result.
    pub correct: [u64; 3],
    /// Number of correct subgoals, in the inclusive range zero to three.
    pub g: u64,
    /// Parent completion: all three subgoals are correct (zero or one).
    pub p: u64,
    /// Actual edit commands plus added supports plus defined truth changes.
    pub c: u64,
    /// Query agreement minus measured work, using the bound task coefficients.
    pub v: i64,
    /// Whether the candidate satisfies the task scope and hard constraints.
    pub eligible: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct DeviceTaskEvaluation {
    lane_refusal: [u64; 2],
    query_receipts: [[[u64; 42]; 3]; 3],
    query_count: u64,
    winner: u64,
    return_value: i64,
    facts: [SemanticTaskFacts; 3],
}

/// Exact piecewise-linear cell selected by the device policy forward pass.
/// The separate retained masks carry the categorical support and active set.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct SemanticPolicyPwlCell {
    abi: u64,
    ordinal: u64,
    cardinality: u64,
    legal_count: u64,
    active_count: u64,
    selected_rank: u64,
    maximum_bits: u64,
    singleton: u64,
    g: [u64; 3],
    active_sum: [u64; 3],
    selected_probability: [u64; 3],
    probability_denominator: [u64; 3],
}

/// Producer-owned selected-score differential operator retained by the forward
/// pass. Together with the exact active set it determines the categorical VJP.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct SemanticPolicySelectedScoreVjp {
    abi: u64,
    ordinal: u64,
    choice: u64,
    active_count: u64,
    selected_active: u64,
    singleton: u64,
    probability_numerator: [u64; 3],
    probability_denominator: [u64; 3],
}

/// Device-sealed receipt for the complete action batch. The root is SHA-256 of
/// these exact bytes and therefore cannot be substituted by a task identity or
/// a digest of component receipts alone.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct SemanticActionBatchReceipt {
    abi: u64,
    proposal: u64,
    stream_serial: u64,
    family_id: u64,
    action_law_generation: u64,
    model_generation: u64,
    actor_eligible: u64,
    component_count: u64,
    candidate_count: u64,
    winner: u64,
    total_return_bits: u64,
    base_word: u64,
    next_word: u64,
    rng_base: u64,
    rng_span: u64,
    rng_successor: u64,
    catalogue_digest: Identity256,
    component_receipts_digest: Identity256,
    semantic_receipts_digest: Identity256,
    candidate_roots: [Identity256; 3],
    base_logical_digest: Identity256,
    execution_work: ExecutionWork,
}

#[repr(C)]
#[derive(Clone, Copy)]
struct DeviceState {
    model_generation: u32,
    family_id: u32,
    stream_serial: u64,
    proposal: u64,
    next_proposal: u64,
    blocks: u64,
    status: u64,
    catalogue_generation: u64,
    catalogue_digest: Identity256,
    binding_digest: Identity256,
    semantic_receipts: [[u64; 42]; 7],
    work: [SemanticTransitionWork; 2],
    importance_weight: f64,
    retired_roots_mask: u64,
    cleanup_receipts: [[u64; 42]; 3],
    task_evaluation: DeviceTaskEvaluation,
    actor_eligible: u64,
    execution_work: ExecutionWork,
    action_batch: SemanticActionBatchReceipt,
    action_batch_root: Identity256,
}

impl Default for DeviceState {
    fn default() -> Self {
        // SAFETY: the scalar ABI admits every bit pattern; zero initializes all
        // integers and the floating-point importance weight.
        unsafe { std::mem::zeroed() }
    }
}

// SAFETY: C layout, integer and FP64 fields; all bit patterns are valid.
unsafe impl DeviceRepr for DeviceState {}
unsafe impl DeviceRepr for SemanticPolicyPwlCell {}
unsafe impl DeviceRepr for SemanticPolicySelectedScoreVjp {}
unsafe impl DeviceRepr for SemanticActionBatchReceipt {}

const _: () = assert!(size_of::<SemanticPolicyPwlCell>() == 160);
const _: () = assert!(size_of::<SemanticPolicySelectedScoreVjp>() == 96);
const _: () = assert!(size_of::<SemanticActionBatchReceipt>() == 504);

/// Original active-ring source slot. Kind and provenance are independent: a
/// filled model-input row is not an assertion that the token was observed.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticTextSlot {
    pub token: u64,
    pub logical_position: u64,
    /// Padding = 0, filled = 1, mask = 2. Active validity is derived from kind.
    pub kind: u64,
    /// Absent = 0, source = 1, generated = 2; only filled rows have a subtype.
    pub provenance: u64,
    pub valid: u64,
    pub committed: u64,
    pub recomputed: u64,
    /// Row in the retained full source-provenance table, not an authority bit.
    pub provenance_record: u64,
}

type SourceSlot = SemanticTextSlot;

// SAFETY: C layout containing only u64 values; all bit patterns are valid.
unsafe impl DeviceRepr for SourceSlot {}

/// Semantic role of a retained state range. Indices name actual layers, tensors,
/// or records inside the cold-bound role roster, never arbitrary device pointers.
#[repr(u64)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum SemanticStateRole {
    PrefixSource = 1,
    TokenProvenanceRecords = 2,
    PrefixIdentity = 3,
    AttentionKeys = 4,
    AttentionValues = 5,
    ConvolutionState = 6,
    RecurrentState = 7,
    ValueRunningMax = 8,
    ValueDenominator = 9,
    ValueNumerator = 10,
    EditRunningMax = 11,
    EditDenominator = 12,
    EditNumerator = 13,
    CompletionCoverage = 14,
    RawFeedback = 15,
    FeedbackStatements = 16,
    FeedbackSupportProvenance = 17,
    SlowWeights = 18,
    FastAdapters = 19,
    SymbolicHeads = 20,
    OptimizerState = 21,
    LossScaler = 22,
    TrainingSchedule = 23,
    Gradients = 24,
    GradientAccumulation = 25,
    OtherRng = 26,
    ReplayEntries = 27,
    ReplayPayload = 28,
    TrainingView = 29,
    IntentEntries = 30,
    IntentPayload = 31,
    Acknowledgements = 32,
    AttemptReceipt = 33,
    GoalState = 34,
    WorldLineage = 35,
    EditJournal = 36,
    Environment = 37,
    AuthorityEnvelope = 38,
    AuthorityDecisions = 39,
    CheckpointLineage = 40,
    SchemaContract = 41,
    TokenizerContract = 42,
    RuntimeContract = 43,
    ModelContract = 44,
    TopologyContract = 45,
    PositionTable = 46,
    ActionCatalogue = 47,
    ActionCodebooks = 48,
    ProofRecords = 49,
    LearningCopyReset = 50,
    ActiveAttentionKeys = 51,
    ActiveAttentionValues = 52,
    ActiveConvolution = 53,
    ActiveRecurrent = 54,
    TensorLayout = 55,
}

impl SemanticStateRole {
    pub fn from_code(code: u64) -> Option<Self> {
        const ROLES: [SemanticStateRole; 55] = [
            SemanticStateRole::PrefixSource,
            SemanticStateRole::TokenProvenanceRecords,
            SemanticStateRole::PrefixIdentity,
            SemanticStateRole::AttentionKeys,
            SemanticStateRole::AttentionValues,
            SemanticStateRole::ConvolutionState,
            SemanticStateRole::RecurrentState,
            SemanticStateRole::ValueRunningMax,
            SemanticStateRole::ValueDenominator,
            SemanticStateRole::ValueNumerator,
            SemanticStateRole::EditRunningMax,
            SemanticStateRole::EditDenominator,
            SemanticStateRole::EditNumerator,
            SemanticStateRole::CompletionCoverage,
            SemanticStateRole::RawFeedback,
            SemanticStateRole::FeedbackStatements,
            SemanticStateRole::FeedbackSupportProvenance,
            SemanticStateRole::SlowWeights,
            SemanticStateRole::FastAdapters,
            SemanticStateRole::SymbolicHeads,
            SemanticStateRole::OptimizerState,
            SemanticStateRole::LossScaler,
            SemanticStateRole::TrainingSchedule,
            SemanticStateRole::Gradients,
            SemanticStateRole::GradientAccumulation,
            SemanticStateRole::OtherRng,
            SemanticStateRole::ReplayEntries,
            SemanticStateRole::ReplayPayload,
            SemanticStateRole::TrainingView,
            SemanticStateRole::IntentEntries,
            SemanticStateRole::IntentPayload,
            SemanticStateRole::Acknowledgements,
            SemanticStateRole::AttemptReceipt,
            SemanticStateRole::GoalState,
            SemanticStateRole::WorldLineage,
            SemanticStateRole::EditJournal,
            SemanticStateRole::Environment,
            SemanticStateRole::AuthorityEnvelope,
            SemanticStateRole::AuthorityDecisions,
            SemanticStateRole::CheckpointLineage,
            SemanticStateRole::SchemaContract,
            SemanticStateRole::TokenizerContract,
            SemanticStateRole::RuntimeContract,
            SemanticStateRole::ModelContract,
            SemanticStateRole::TopologyContract,
            SemanticStateRole::PositionTable,
            SemanticStateRole::ActionCatalogue,
            SemanticStateRole::ActionCodebooks,
            SemanticStateRole::ProofRecords,
            SemanticStateRole::LearningCopyReset,
            SemanticStateRole::ActiveAttentionKeys,
            SemanticStateRole::ActiveAttentionValues,
            SemanticStateRole::ActiveConvolution,
            SemanticStateRole::ActiveRecurrent,
            SemanticStateRole::TensorLayout,
        ];
        let index = usize::try_from(code.checked_sub(1)?).ok()?;
        ROLES.get(index).copied()
    }
}

/// One actual canonical control record or queue payload retained by a parent.
/// Mutable queue capacity is explicit; bytes contain the real encoded header
/// and entries, including an empty queue's header rather than an invented state.
pub struct SemanticStateRecord {
    pub role: SemanticStateRole,
    pub index: u64,
    pub bytes: Vec<u8>,
    pub capacity_bytes: usize,
}

/// Byte spans in the producer's one ModelContract record. The native owner
/// hashes the immutable schema bytes without interpreting their format, then
/// binds them to the actual model generation and device numerical identity.
/// Digest fields are raw 32 bytes; generation is an unaligned little-endian u64.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticModelContractLayout {
    pub schema_begin: u64,
    pub schema_bytes: u64,
    pub schema_digest_offset: u64,
    pub generation_offset: u64,
    pub numerical_digest_offset: u64,
    pub identity_offset: u64,
}

impl SemanticModelContractLayout {
    fn validate(self, record_bytes: u64) -> Result<(), SemanticTransitionError> {
        let spans = [
            (self.schema_begin, self.schema_bytes),
            (self.schema_digest_offset, 32),
            (self.generation_offset, 8),
            (self.numerical_digest_offset, 32),
            (self.identity_offset, 32),
        ];
        for (index, &(begin, bytes)) in spans.iter().enumerate() {
            if bytes == 0
                || begin > record_bytes
                || bytes > record_bytes - begin
                || spans[..index]
                    .iter()
                    .any(|&(other, length)| begin < other + length && other < begin + bytes)
            {
                return Err(publication_input_error(
                    "model contract spans must be nonempty, disjoint and within its actual bytes",
                ));
            }
        }
        Ok(())
    }
}

/// A genuine producer-owned model tensor and its exact cold model contract.
/// No numeric conversion occurs. Logical intervals describe covered positions;
/// non-positional weights and optimizer state use the explicit interval 0..0.
pub struct SemanticTensorInput {
    pub layout: SemanticTensorLayout,
    pub logical_begin: u64,
    pub logical_end: u64,
    pub tensor: DlpackManagedTensor,
    /// Retained native allocation origin of this actual producer, if any.
    /// This is not a reader grant or a tensor version-counter identity.
    pub native_allocation: Option<DeviceAllocationProvenance>,
}

/// Retained original tensor producers for one prepared bank's autograd
/// delivery boundary. The binding owns the consumed DLPack records until the
/// Python-side delivery owner is retired; it grants no publication authority.
pub struct SemanticGradientDeliveryBinding {
    _tensors: Vec<PreparedSemanticTensor>,
}

/// A producer-declared storage object within one complete backing allocation.
/// Storage identity is its ordinal, not an address or a tensor version counter.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticModelStorage {
    pub allocation: u64,
    pub byte_offset: u64,
    pub span_bytes: u64,
}

/// A typed publication coordinate within a producer-declared storage object.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticModelView {
    pub role: u64,
    pub index: u64,
    pub storage: u64,
    pub byte_offset: u64,
}

/// Full producer-owned backing buffers and their independent storage/view map.
/// Allocation inputs are contiguous U8 vectors with role zero and ordinal index.
/// Tensor and version-counter identities remain in the opaque model contract.
pub struct SemanticModelMemory {
    pub allocations: Vec<SemanticTensorInput>,
    pub storages: Vec<SemanticModelStorage>,
    pub views: Vec<SemanticModelView>,
}

#[derive(Clone, Debug, Default, PartialEq, Eq)]
struct ModelMemoryGeometry {
    allocation_bytes: Vec<u64>,
    storages: Vec<SemanticModelStorage>,
    views: Vec<SemanticModelView>,
}

impl ModelMemoryGeometry {
    fn location(&self, role: u64, index: u64) -> Result<(usize, usize), SemanticTransitionError> {
        let view = self
            .views
            .iter()
            .find(|view| (view.role, view.index) == (role, index))
            .ok_or_else(|| {
                publication_input_error("model tensor lacks its producer storage view")
            })?;
        let storage = usize::try_from(view.storage)
            .ok()
            .and_then(|index| self.storages.get(index))
            .ok_or_else(|| publication_input_error("model view names an absent storage object"))?;
        let allocation = usize::try_from(storage.allocation)
            .ok()
            .filter(|&index| index < self.allocation_bytes.len())
            .ok_or_else(|| {
                publication_input_error("model storage names an absent backing allocation")
            })?;
        let offset = storage
            .byte_offset
            .checked_add(view.byte_offset)
            .and_then(|offset| usize::try_from(offset).ok())
            .ok_or_else(|| publication_input_error("model storage view offset overflows"))?;
        Ok((allocation, offset))
    }

    fn validate(
        &self,
        layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    ) -> Result<(), SemanticTransitionError> {
        let mut allocations = BTreeSet::new();
        for storage in &self.storages {
            let capacity = usize::try_from(storage.allocation)
                .ok()
                .and_then(|index| self.allocation_bytes.get(index))
                .ok_or_else(|| publication_input_error("model storage allocation is absent"))?;
            if usize::try_from(*capacity).is_err()
                || storage
                    .byte_offset
                    .checked_add(storage.span_bytes)
                    .is_none_or(|end| end > *capacity)
            {
                return Err(publication_input_error(
                    "model storage exceeds its complete backing allocation",
                ));
            }
            allocations.insert(storage.allocation);
        }
        let mut storages = BTreeSet::new();
        let mut previous = None;
        for view in &self.views {
            let key = (view.role, view.index);
            if !matches!(view.role, 18..=25) || previous.is_some_and(|previous| previous >= key) {
                return Err(publication_input_error(
                    "model views must enumerate unique model tensor coordinates in order",
                ));
            }
            previous = Some(key);
            let layout = layouts.get(&key).ok_or_else(|| {
                publication_input_error("model storage view lacks its original tensor layout")
            })?;
            let (_, offset) = self.location(view.role, view.index)?;
            let storage = &self.storages[view.storage as usize];
            let span = tensor_layout_bytes(layout)? as u64;
            if layout.logical_axis != u64::MAX
                || !(offset as u64).is_multiple_of(layout.element_bytes)
                || view
                    .byte_offset
                    .checked_add(span)
                    .is_none_or(|end| end > storage.span_bytes)
            {
                return Err(publication_input_error(
                    "typed model view exceeds or misaligns its declared storage",
                ));
            }
            storages.insert(view.storage);
        }
        if allocations.len() != self.allocation_bytes.len()
            || storages.len() != self.storages.len()
            || self.views.len()
                != layouts
                    .values()
                    .filter(|layout| matches!(layout.role, 18..=25))
                    .count()
        {
            return Err(publication_input_error(
                "model memory map omits a tensor or contains unreachable storage",
            ));
        }
        Ok(())
    }

    fn encode_into(&self, bytes: &mut Vec<u8>) -> Result<(), SemanticTransitionError> {
        for count in [
            self.allocation_bytes.len(),
            self.storages.len(),
            self.views.len(),
        ] {
            material_u32(
                bytes,
                u32::try_from(count).map_err(|_| SemanticTransitionError::GenerationExhausted)?,
            );
        }
        for &extent in &self.allocation_bytes {
            material_u64(bytes, extent);
        }
        for storage in &self.storages {
            for field in [storage.allocation, storage.byte_offset, storage.span_bytes] {
                material_u64(bytes, field);
            }
        }
        for view in &self.views {
            for field in [view.role, view.index, view.storage, view.byte_offset] {
                material_u64(bytes, field);
            }
        }
        Ok(())
    }

    fn digest(
        &self,
        layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    ) -> Result<Identity256, SemanticTransitionError> {
        self.validate(layouts)?;
        let mut bytes = b"xlog.semantic.model-memory.v1\0".to_vec();
        self.encode_into(&mut bytes)?;
        let model = layouts
            .values()
            .filter(|layout| matches!(layout.role, 18..=25));
        material_u64(&mut bytes, model.clone().count() as u64);
        for layout in model {
            for field in [
                layout.role,
                layout.index,
                layout.element_bytes,
                layout.scalar_type,
                layout.rank,
                layout.logical_axis,
            ]
            .into_iter()
            .chain(layout.dimensions)
            .chain(layout.strides_bytes)
            {
                material_u64(&mut bytes, field);
            }
        }
        Ok(Identity256::from_bytes(Sha256::digest(&bytes).into()))
    }

    fn decode_from(
        reader: &mut SemanticMaterialReader<'_>,
    ) -> Result<Self, SemanticTransitionError> {
        let allocations = reader.count(8).map_err(SemanticTransitionError::Semantic)?;
        let storages = reader
            .count(24)
            .map_err(SemanticTransitionError::Semantic)?;
        let views = reader
            .count(32)
            .map_err(SemanticTransitionError::Semantic)?;
        let mut geometry = Self::default();
        for _ in 0..allocations {
            geometry
                .allocation_bytes
                .push(reader.u64().map_err(SemanticTransitionError::Semantic)?);
        }
        for _ in 0..storages {
            geometry.storages.push(SemanticModelStorage {
                allocation: reader.u64().map_err(SemanticTransitionError::Semantic)?,
                byte_offset: reader.u64().map_err(SemanticTransitionError::Semantic)?,
                span_bytes: reader.u64().map_err(SemanticTransitionError::Semantic)?,
            });
        }
        for _ in 0..views {
            geometry.views.push(SemanticModelView {
                role: reader.u64().map_err(SemanticTransitionError::Semantic)?,
                index: reader.u64().map_err(SemanticTransitionError::Semantic)?,
                storage: reader.u64().map_err(SemanticTransitionError::Semantic)?,
                byte_offset: reader.u64().map_err(SemanticTransitionError::Semantic)?,
            });
        }
        Ok(geometry)
    }
}

fn prepare_model_memory(
    allocations: &[PreparedSemanticTensor],
    storages: Vec<SemanticModelStorage>,
    views: Vec<SemanticModelView>,
    tensors: &[PreparedSemanticTensor],
) -> Result<ModelMemoryGeometry, SemanticTransitionError> {
    let mut geometry = ModelMemoryGeometry {
        allocation_bytes: Vec::new(),
        storages,
        views,
    };
    for (index, allocation) in allocations.iter().enumerate() {
        let layout = allocation.layout;
        if layout.role != 0
            || layout.index != index as u64
            || layout.rank != 1
            || layout.scalar_type != 1
            || layout.element_bytes != 1
            || layout.logical_axis != u64::MAX
            || layout.strides_bytes != [1, 0, 0, 0]
            || allocation.logical_begin != 0
            || allocation.logical_end != 0
        {
            return Err(publication_input_error(
                "model backing producer must be its complete ordinal U8 vector",
            ));
        }
        let bytes = tensor_layout_bytes(&layout)? as u64;
        let end = allocation
            .data
            .checked_add(bytes)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        // Validate distinct declared owners; never infer identity from addresses.
        for (prior, &prior_bytes) in allocations[..index].iter().zip(&geometry.allocation_bytes) {
            if bytes != 0
                && prior_bytes != 0
                && allocation.data < prior.data + prior_bytes
                && prior.data < end
            {
                return Err(publication_input_error(
                    "declared model backing allocations overlap",
                ));
            }
        }
        geometry.allocation_bytes.push(bytes);
    }
    let layouts = tensors
        .iter()
        .map(|tensor| ((tensor.layout.role, tensor.layout.index), tensor.layout))
        .collect();
    geometry.validate(&layouts)?;
    for tensor in tensors
        .iter()
        .filter(|tensor| matches!(tensor.layout.role, 18..=25))
    {
        let (allocation, offset) = geometry.location(tensor.layout.role, tensor.layout.index)?;
        if allocations[allocation].data.checked_add(offset as u64) != Some(tensor.data) {
            return Err(publication_input_error(
                "original tensor does not occupy its producer-declared backing view",
            ));
        }
    }
    Ok(geometry)
}

/// Initial canonical parent only. A model continuation cannot be supplied here:
/// it is admitted after a real Acquire and a forward using that acquired parent.
/// PrefixIdentity is native-owned: fresh publication derives its 32 bytes from
/// the actual PrefixSource. Supplying a caller record for that role is an error.
pub struct SemanticParentBinding {
    pub recovered_instance: Option<Identity256>,
    pub source: [SemanticTextSlot; 32],
    pub prefix: Vec<SemanticTextSlot>,
    pub ring_head: u64,
    pub provenance_records: u64,
    pub prefix_capacity: u64,
    pub feedback_capacity: u64,
    pub max_position: u64,
    pub pad_token: u64,
    pub terminal_tokens: Vec<u64>,
    pub final_intent_payload_bytes: u64,
    /// Actual application effect descriptor. The native owner constructs the
    /// empty intent queue; callers never encode its private header or entries.
    pub intent_effect: Vec<u8>,
    pub intent_entry_capacity: u64,
    pub intent_payload_capacity_bytes: usize,
    pub acknowledgement_payload_capacity_bytes: usize,
    pub model_generation: u64,
    /// Complete versioned numerical-mode contribution from the model owner.
    /// The Python binding uses exact canonical ColdValue metadata, not a digest
    /// or repr. Native code owns the surrounding RuntimeContract record.
    pub model_numerical_mode: Vec<u8>,
    pub model_contract_layout: SemanticModelContractLayout,
    pub policy_generation: u64,
    pub neural_generation: u64,
    pub cache_generation: u64,
    pub authority_generation: u64,
    pub training_cursor: u64,
    pub training_rng: [u64; 4],
    pub fuel: u64,
    pub rng: SemanticRngBinding,
    pub topology_identity: Identity256,
    pub table_identity: Identity256,
    /// Every one of the 55 roles is explicit, including actual zero tensor counts.
    pub role_counts: [u64; 55],
    pub records: Vec<SemanticStateRecord>,
    pub tensors: Vec<SemanticTensorInput>,
    pub model_memory: SemanticModelMemory,
    /// Model-declared 51..54 capacities only; no active output exists before
    /// Acquire and the original forward. Initial ranges are unreachable.
    pub active_layouts: Vec<SemanticTensorLayout>,
}

/// An observed token payload admitted by the trusted application controller.
/// `origin` retains the complete source/manifest/transformation record, not an
/// independently supplied native digest or a model-generated provenance row.
#[derive(Clone, Debug)]
pub struct SemanticObservedSource {
    pub identity: String,
    pub tokens: Vec<u64>,
    pub origin: Vec<u8>,
}

/// A token is selected only by offset into its admitted observed payload.
#[derive(Clone, Debug)]
pub struct SemanticSourceMapping {
    pub source: String,
    pub offset: u64,
    pub logical_position: u64,
}

/// Initial source geometry issued from the admitted observation mapping before
/// the model computes its prefix cache. The rows retain zero provenance indices;
/// parent binding constructs and verifies the private ledger after prefill.
#[derive(Clone)]
pub struct SemanticInitialSourceLayout {
    pub source: [SemanticTextSlot; 32],
    pub prefix: Vec<SemanticTextSlot>,
    pub prefill_tokens: Vec<u64>,
    pub ring_head: u64,
    #[cfg(feature = "semantic-policy")]
    prefill_mapping: Vec<SemanticSourceMapping>,
    provenance_bytes: Vec<u8>,
    provenance_capacity_bytes: usize,
    provenance_records: u64,
}

/// One imported task's pre-parent model input. Its source and owner are fixed
/// before the actual model call; no second stage can be issued on this Session.
struct InitialPrefillStage {
    scope: Arc<()>,
    task_identity: Identity256,
    task_epoch: u64,
    model_generation: u64,
    layout: SemanticInitialSourceLayout,
    expected_tokens: TrackedCudaSlice<u64>,
    input: Option<PreparedSemanticTensor>,
    model_content: Option<TensorContentBuffers>,
    output_content: Option<TensorContentBuffers>,
    captured_content: Vec<TensorContentBuffers>,
    consumer_stream: Option<u64>,
}

/// Content needed by the original forward after the one-use prefill stage has
/// joined its parent. The Session owns it until its final stream-safe release.
struct RetainedInitialPrefillContent {
    scope: Arc<()>,
    task_identity: Identity256,
    task_epoch: u64,
    model_generation: u64,
    model: TensorContentBuffers,
    #[cfg(feature = "semantic-policy")]
    output: TensorContentBuffers,
    #[cfg(feature = "semantic-policy")]
    record: InitialPrefillRecord,
    captured: Vec<TensorContentBuffers>,
}

#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
struct InitialPrefillRecord {
    predecessor: SemanticPublishedIdentity,
    semantic_root: Identity256,
    task_identity: Identity256,
    task_epoch: u64,
    task_content: SemanticTaskContentIdentity,
    model_generation: u64,
    tokens: Vec<u64>,
    mapping: Vec<SemanticSourceMapping>,
}

struct CheckpointInitialPrefill {
    original: SemanticPublishedIdentity,
    content: Vec<u8>,
    recovery_referent: Option<Vec<u8>>,
}

impl CheckpointInitialPrefill {
    const MAGIC: &'static [u8] = b"XLOG-CHECKPOINT-INITIAL-PREFILL\0";

    fn encode_section(value: Option<&Self>) -> Result<Vec<u8>, SemanticTransitionError> {
        let mut bytes = Self::MAGIC.to_vec();
        material_u64(&mut bytes, 1);
        if let Some(value) = value {
            bytes.push(1);
            encode_publication_identity(&mut bytes, value.original);
            material_u64(
                &mut bytes,
                u64::try_from(value.content.len())
                    .map_err(|_| publication_input_error("initial prefill exceeds u64"))?,
            );
            bytes.extend_from_slice(&value.content);
        } else {
            bytes.push(0);
        }
        Ok(bytes)
    }

    fn decode_section(bytes: &[u8]) -> Result<Option<Self>, SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(bytes);
        if reader
            .take(Self::MAGIC.len())
            .map_err(SemanticTransitionError::Semantic)?
            != Self::MAGIC
            || reader.u64().map_err(SemanticTransitionError::Semantic)? != 1
        {
            return Err(publication_input_error(
                "checkpoint initial prefill has another domain or version",
            ));
        }
        let result = match reader.u8().map_err(SemanticTransitionError::Semantic)? {
            0 => None,
            1 => {
                let original = decode_publication_identity(&mut reader)?;
                let length =
                    usize::try_from(reader.u64().map_err(SemanticTransitionError::Semantic)?)
                        .map_err(|_| {
                            publication_input_error("checkpoint initial prefill exceeds this host")
                        })?;
                let content = reader
                    .take(length)
                    .map_err(SemanticTransitionError::Semantic)?
                    .to_vec();
                if content.is_empty() {
                    return Err(publication_input_error(
                        "checkpoint initial prefill is empty",
                    ));
                }
                Some(Self {
                    original,
                    content,
                    recovery_referent: None,
                })
            }
            _ => {
                return Err(publication_input_error(
                    "checkpoint initial prefill presence is invalid",
                ))
            }
        };
        reader.finish().map_err(SemanticTransitionError::Semantic)?;
        Ok(result)
    }

    fn verify_content(
        &self,
        semantic_root: Identity256,
        model_generation: u64,
        task_identity: Identity256,
        task_epoch: u64,
        task_content: SemanticTaskContentIdentity,
        prefix_extent: u64,
    ) -> Result<(), SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(&self.content);
        let read_identity = |reader: &mut SemanticMaterialReader<'_>| {
            reader
                .take(32)
                .map(|value| Identity256::from_bytes(value.try_into().unwrap()))
                .map_err(SemanticTransitionError::Semantic)
        };
        if read_identity(&mut reader)? != semantic_root
            || reader.u64().map_err(SemanticTransitionError::Semantic)? != model_generation
            || read_identity(&mut reader)? != task_identity
            || reader.u64().map_err(SemanticTransitionError::Semantic)? != task_epoch
            || [
                read_identity(&mut reader)?,
                read_identity(&mut reader)?,
                read_identity(&mut reader)?,
            ] != [
                task_content.query,
                task_content.theory_program,
                task_content.result,
            ]
        {
            return Err(publication_input_error(
                "checkpoint initial prefill differs from its native task or parent",
            ));
        }
        let count = reader.u64().map_err(SemanticTransitionError::Semantic)?;
        if count == 0 || count != prefix_extent {
            return Err(publication_input_error(
                "checkpoint initial prefill token extent differs",
            ));
        }
        for _ in 0..count {
            reader.u64().map_err(SemanticTransitionError::Semantic)?;
        }
        if reader.u64().map_err(SemanticTransitionError::Semantic)? != count {
            return Err(publication_input_error(
                "checkpoint initial prefill mapping extent differs",
            ));
        }
        for position in 0..count {
            let length = usize::try_from(reader.u64().map_err(SemanticTransitionError::Semantic)?)
                .map_err(|_| {
                    publication_input_error("initial prefill source name exceeds this host")
                })?;
            let source = reader
                .take(length)
                .map_err(SemanticTransitionError::Semantic)?;
            if source.is_empty() || std::str::from_utf8(source).is_err() {
                return Err(publication_input_error(
                    "checkpoint initial prefill source name is invalid",
                ));
            }
            reader.u64().map_err(SemanticTransitionError::Semantic)?;
            if reader.u64().map_err(SemanticTransitionError::Semantic)? != position {
                return Err(publication_input_error(
                    "checkpoint initial prefill logical positions differ",
                ));
            }
        }
        for model in [true, false] {
            let count = reader.u64().map_err(SemanticTransitionError::Semantic)?;
            if count == 0 {
                return Err(publication_input_error(
                    "checkpoint initial prefill has an empty seal group",
                ));
            }
            for _ in 0..count {
                let role = reader.u64().map_err(SemanticTransitionError::Semantic)?;
                if if model {
                    !matches!(role, 0 | 18..=25)
                } else {
                    !matches!(role, 4..=13)
                } {
                    return Err(publication_input_error(
                        "checkpoint initial prefill seal role is invalid",
                    ));
                }
                reader.u64().map_err(SemanticTransitionError::Semantic)?;
                reader.take(32).map_err(SemanticTransitionError::Semantic)?;
            }
        }
        reader.finish().map_err(SemanticTransitionError::Semantic)?;
        Ok(())
    }

    fn verify_recorded_content(
        &self,
        task_identity: Identity256,
        task_epoch: u64,
        task_content: SemanticTaskContentIdentity,
    ) -> Result<(), SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(&self.content);
        let semantic_root = Identity256::from_bytes(
            reader
                .take(32)
                .map_err(SemanticTransitionError::Semantic)?
                .try_into()
                .unwrap(),
        );
        let model_generation = reader.u64().map_err(SemanticTransitionError::Semantic)?;
        reader
            .take(32 + 8 + 3 * 32)
            .map_err(SemanticTransitionError::Semantic)?;
        let prefix_extent = reader.u64().map_err(SemanticTransitionError::Semantic)?;
        self.verify_content(
            semantic_root,
            model_generation,
            task_identity,
            task_epoch,
            task_content,
            prefix_extent,
        )
    }
}

/// Opaque handle to the single imported-task prefill stage. This is not a
/// model-forward receipt; the actual input and outputs must be joined before
/// the parent can be published.
#[derive(Clone)]
pub struct SemanticInitialPrefillLease {
    issuer: Arc<()>,
    scope: Arc<()>,
}

#[derive(Clone, Copy)]
enum InitialPrefillContentSlot {
    Model,
    Captured(usize),
}

#[derive(Clone, Copy)]
enum InitialPrefillCaptureKind {
    Model,
    Outputs,
    Captured,
}

/// Exact content captured by one imported task's original model prefill.
/// This handle never creates a new baseline during verification.
#[derive(Clone)]
pub struct SemanticInitialPrefillContentWitness {
    issuer: Arc<()>,
    scope: Arc<()>,
    task_identity: Identity256,
    task_epoch: u64,
    model_generation: u64,
    slot: InitialPrefillContentSlot,
}

impl SemanticInitialPrefillContentWitness {
    fn matches(
        &self,
        issuer: &Arc<()>,
        scope: &Arc<()>,
        task_identity: Identity256,
        task_epoch: u64,
        model_generation: u64,
        captured_count: usize,
    ) -> bool {
        Arc::ptr_eq(&self.issuer, issuer)
            && Arc::ptr_eq(&self.scope, scope)
            && self.task_identity == task_identity
            && self.task_epoch == task_epoch
            && self.model_generation == model_generation
            && match self.slot {
                InitialPrefillContentSlot::Model => true,
                InitialPrefillContentSlot::Captured(index) => index < captured_count,
            }
    }
}

fn validate_initial_prefill_input_layout(
    layout: &SemanticTensorLayout,
    token_count: u64,
) -> Result<(), SemanticTransitionError> {
    let row_bytes = token_count
        .checked_mul(size_of::<i64>() as u64)
        .filter(|_| token_count != 0)
        .ok_or_else(|| {
            publication_input_error("initial prefill requires nonempty admitted prefix tokens")
        })?;
    if *layout
        != (SemanticTensorLayout {
            role: 0,
            index: 0,
            element_bytes: size_of::<i64>() as u64,
            scalar_type: 7,
            rank: 2,
            logical_axis: 1,
            dimensions: [1, token_count, 0, 0],
            strides_bytes: [row_bytes, size_of::<i64>() as u64, 0, 0],
        })
    {
        return Err(publication_input_error(
            "initial prefill input must be the exact contiguous I64 model token tensor [1,prefix]",
        ));
    }
    Ok(())
}

fn same_initial_source_rows(expected: &[SemanticTextSlot], actual: &[SemanticTextSlot]) -> bool {
    expected.len() == actual.len()
        && expected.iter().zip(actual).all(|(expected, actual)| {
            SemanticTextSlot {
                provenance_record: 0,
                ..*expected
            } == SemanticTextSlot {
                provenance_record: 0,
                ..*actual
            }
        })
}

/// Place the exact admitted tokens into an ordered computed prefix and original
/// 32-row ring. No model cache or publication is claimed by this cold plan.
/// The existing parent bind rechecks the same source mapping and cache geometry.
#[expect(
    clippy::too_many_arguments,
    reason = "cold planning checks the admitted source and complete parent text geometry together"
)]
pub fn initial_source_layout(
    sources: &[SemanticObservedSource],
    mapping: &[SemanticSourceMapping],
    authority: &[u8],
    generation: u64,
    provenance_capacity_records: u64,
    prefix_capacity: u64,
    feedback_capacity: u64,
    max_position: u64,
    pad_token: u64,
) -> Result<SemanticInitialSourceLayout, SemanticTransitionError> {
    let invalid = publication_input_error;
    if pad_token >= TEXT_CARDINALITY as u64 {
        return Err(invalid(
            "initial source padding token is outside the text vocabulary",
        ));
    }
    let last_position = mapping.iter().map(|entry| entry.logical_position).max();
    let source_extent = last_position
        .map(|last| {
            last.checked_add(1)
                .ok_or_else(|| invalid("initial source position overflows"))
        })
        .transpose()?
        .unwrap_or(0);
    let prefix_extent = source_extent.saturating_sub(32);
    if prefix_extent > prefix_capacity || prefix_extent > mapping.len() as u64 {
        return Err(invalid(
            "admitted source exceeds its complete prefix capacity",
        ));
    }
    let admitted = sources
        .iter()
        .map(|source| (source.identity.as_str(), source))
        .collect::<BTreeMap<_, _>>();
    let mut tokens = BTreeMap::new();
    for entry in mapping {
        let source = admitted
            .get(entry.source.as_str())
            .ok_or_else(|| invalid("source mapping names an unadmitted payload"))?;
        let offset =
            usize::try_from(entry.offset).map_err(|_| invalid("source token offset overflows"))?;
        let token = *source
            .tokens
            .get(offset)
            .ok_or_else(|| invalid("source mapping token offset is out of range"))?;
        if tokens.insert(entry.logical_position, token).is_some() {
            return Err(invalid("source mapping repeats a logical position"));
        }
    }
    let mut source = [SemanticTextSlot {
        token: pad_token,
        ..SemanticTextSlot::default()
    }; 32];
    let mut prefix = Vec::with_capacity(prefix_extent as usize);
    let mut prefill_tokens = Vec::with_capacity(prefix_extent as usize);
    for position in 0..prefix_extent {
        let token = *tokens
            .get(&position)
            .ok_or_else(|| invalid("computed prefix lacks an admitted source token"))?;
        prefix.push(SemanticTextSlot {
            token,
            logical_position: position,
            kind: 1,
            provenance: 1,
            valid: 1,
            committed: 1,
            ..SemanticTextSlot::default()
        });
        prefill_tokens.push(token);
    }
    for (&position, &token) in tokens.range(prefix_extent..) {
        let index = usize::try_from(position - prefix_extent)
            .map_err(|_| invalid("initial source ring offset overflows"))?;
        if index >= source.len() {
            return Err(invalid("admitted source exceeds its 32-row active ring"));
        }
        source[index] = SemanticTextSlot {
            token,
            logical_position: position,
            kind: 1,
            provenance: 1,
            valid: 1,
            ..SemanticTextSlot::default()
        };
    }
    let (_, _, provenance) = initial_source_ledger(
        source,
        prefix.clone(),
        sources,
        mapping,
        authority,
        generation,
        provenance_capacity_records,
    )?;
    #[cfg(feature = "semantic-policy")]
    let mut prefill_mapping = mapping
        .iter()
        .filter(|entry| entry.logical_position < prefix_extent)
        .cloned()
        .collect::<Vec<_>>();
    #[cfg(feature = "semantic-policy")]
    prefill_mapping.sort_by_key(|entry| entry.logical_position);
    let ring_head = (source_extent - prefix_extent) % 32;
    validate_text_parent(
        &source,
        prefix_extent,
        prefix_capacity,
        feedback_capacity,
        max_position,
        ring_head,
        mapping.len() as u64,
    )?;
    Ok(SemanticInitialSourceLayout {
        source,
        prefix,
        prefill_tokens,
        ring_head,
        #[cfg(feature = "semantic-policy")]
        prefill_mapping,
        provenance_bytes: provenance.bytes,
        provenance_capacity_bytes: provenance.capacity_bytes,
        provenance_records: mapping.len() as u64,
    })
}

impl SemanticParentBinding {
    /// Construct the private initial SOURCE ledger from admitted observations.
    /// The complete authority record is retained in the parent by the same
    /// controller. Fresh GENERATED rows must instead enter through restoration.
    pub fn bind_initial_sources(
        &mut self,
        sources: &[SemanticObservedSource],
        mapping: &[SemanticSourceMapping],
        authority: &[u8],
        capacity_records: u64,
    ) -> Result<(), SemanticTransitionError> {
        if self.recovered_instance.is_some()
            || self.provenance_records != 0
            || self
                .records
                .iter()
                .any(|record| record.role == SemanticStateRole::TokenProvenanceRecords)
            || self.role_counts[SemanticStateRole::TokenProvenanceRecords as usize - 1] != 1
        {
            return Err(publication_input_error(
                "fresh source provenance must be constructed by the controller",
            ));
        }
        let (source, prefix, record) = initial_source_ledger(
            self.source,
            self.prefix.clone(),
            sources,
            mapping,
            authority,
            self.authority_generation,
            capacity_records,
        )?;
        self.source = source;
        self.prefix = prefix;
        self.provenance_records = mapping.len() as u64;
        self.records.push(record);
        Ok(())
    }
}

fn initial_source_ledger(
    mut ring: [SemanticTextSlot; 32],
    mut prefix: Vec<SemanticTextSlot>,
    sources: &[SemanticObservedSource],
    mapping: &[SemanticSourceMapping],
    authority: &[u8],
    generation: u64,
    capacity: u64,
) -> Result<
    (
        [SemanticTextSlot; 32],
        Vec<SemanticTextSlot>,
        SemanticStateRecord,
    ),
    SemanticTransitionError,
> {
    let invalid = publication_input_error;
    let source_count = sources.len();
    let sources = sources
        .iter()
        .map(|source| (source.identity.as_str(), source))
        .collect::<BTreeMap<_, _>>();
    if sources.len() != source_count
        || sources.values().any(|source| {
            source.identity.is_empty()
                || source.origin.is_empty()
                || source.tokens.is_empty()
                || source
                    .tokens
                    .iter()
                    .any(|&token| token >= TEXT_CARDINALITY as u64 || token == MASK_TOKEN as u64)
        })
    {
        return Err(invalid(
            "observed sources require unique identities and complete valid token payloads",
        ));
    }
    if authority.is_empty()
        || generation == 0
        || capacity
            < (mapping.len() as u64)
                .checked_add(32)
                .ok_or_else(|| invalid("source ledger capacity overflows"))?
    {
        return Err(invalid(
            "source ledger requires complete authority and append capacity",
        ));
    }
    let mut positions = BTreeMap::new();
    for entry in mapping {
        let source = sources
            .get(entry.source.as_str())
            .ok_or_else(|| invalid("source mapping names an unadmitted payload"))?;
        let offset =
            usize::try_from(entry.offset).map_err(|_| invalid("source token offset overflows"))?;
        if offset >= source.tokens.len()
            || positions.insert(entry.logical_position, entry).is_some()
        {
            return Err(invalid(
                "source mapping has invalid payload, offset, or duplicate logical position",
            ));
        }
    }
    let authority_digest = Identity256::from_bytes(Sha256::digest(authority).into());
    let mut bytes = Vec::with_capacity(
        mapping
            .len()
            .checked_mul(size_of::<TokenProvenance>())
            .ok_or_else(|| invalid("source ledger extent overflows"))?,
    );
    let mut seen = BTreeSet::new();
    for (physical_slot, slot) in prefix.iter_mut().map(|slot| (u64::MAX, slot)).chain(
        ring.iter_mut()
            .enumerate()
            .map(|(index, slot)| (index as u64, slot)),
    ) {
        if slot.kind != 1 {
            if slot.kind > 2 || slot.provenance != 0 || slot.provenance_record != 0 {
                return Err(invalid(
                    "MASK or PAD cannot carry initial SOURCE provenance",
                ));
            }
            continue;
        }
        let entry = positions.get(&slot.logical_position).ok_or_else(|| {
            invalid("every initial FILLED position requires its exact source mapping")
        })?;
        let source = sources[entry.source.as_str()];
        let token = source.tokens[entry.offset as usize];
        if slot.provenance != 1
            || slot.provenance_record != 0
            || slot.token != token
            || !seen.insert(slot.logical_position)
        {
            return Err(invalid(
                "initial FILLED token differs from its admitted SOURCE payload or position",
            ));
        }
        slot.provenance_record = (bytes.len() / size_of::<TokenProvenance>()) as u64;
        let mut record = TokenProvenance {
            source_slot: physical_slot,
            logical_position: entry.logical_position,
            token,
            // For observed inputs ordinal is the exact payload token offset;
            // no action receipt is invented before a real generated transition.
            ordinal: entry.offset,
            authority_generation: generation,
            origin_logical_digest: Identity256::from_bytes(Sha256::digest(&source.origin).into()),
            authority_closure_digest: authority_digest,
            ..TokenProvenance::default()
        };
        // SAFETY: TokenProvenance is a padding-free repr(C) integral record.
        // Every field was initialized; the private record digest starts at zero.
        let logical = unsafe {
            std::slice::from_raw_parts(
                (&record as *const TokenProvenance).cast::<u8>(),
                size_of::<TokenProvenance>(),
            )
        };
        record.record_digest = Identity256::from_bytes(Sha256::digest(logical).into());
        // SAFETY: the same padding-free initialized record is copied, not borrowed.
        bytes.extend_from_slice(unsafe {
            std::slice::from_raw_parts(
                (&record as *const TokenProvenance).cast::<u8>(),
                size_of::<TokenProvenance>(),
            )
        });
    }
    if seen.len() != mapping.len() {
        return Err(invalid(
            "source mapping includes a MASK, PAD, or absent logical position",
        ));
    }
    let capacity_bytes = usize::try_from(capacity)
        .ok()
        .and_then(|count| count.checked_mul(size_of::<TokenProvenance>()))
        .ok_or_else(|| invalid("source ledger capacity overflows"))?;
    Ok((
        ring,
        prefix,
        SemanticStateRecord {
            role: SemanticStateRole::TokenProvenanceRecords,
            index: 0,
            bytes,
            capacity_bytes,
        },
    ))
}

/// Original model outputs for one acquired parent. The Session supplies their
/// instance, publication word, task and generation binding from its real lease.
pub struct SemanticContinuationInput {
    pub tensors: Vec<SemanticTensorInput>,
    /// Exact fresh controller snapshot used to authorize this invocation.
    /// This is not an independently issuable model input or authority claim.
    pub authority_decisions: Vec<u8>,
    /// Original U64[32,2] mapping and U64[1] count, never host-compacted.
    pub text_rows: DlpackManagedTensor,
    pub text_row_count: DlpackManagedTensor,
    /// Original Bool8[32], indexed by acquired source slot.
    pub selected_text: DlpackManagedTensor,
    /// Original U64[A,4] physical mapping and U64[1] count; holes remain holes.
    pub active_rows: DlpackManagedTensor,
    pub active_row_count: DlpackManagedTensor,
    /// Original Bool8[1] ordinary numerical admission predicate.
    pub numerical_admissibility: DlpackManagedTensor,
    /// Original pre-draw FP64[N,2,3] block bounds. Only proposals draw.
    pub numerical_blocks: Option<DlpackManagedTensor>,
    /// Original sealed model-contract schema digest for this block roster.
    pub model_schema_digest: Option<Identity256>,
    /// Original sealed model-contract identity for this generation.
    pub model_identity: Option<Identity256>,
}

fn continuation_service_layouts(
    first_index: usize,
    capacity: u64,
    physical_blocks: Option<usize>,
) -> Result<Vec<SemanticTensorLayout>, SemanticTransitionError> {
    let first_index = u64::try_from(first_index)
        .ok()
        .filter(|index| {
            index
                .checked_add(if physical_blocks.is_some() { 6 } else { 5 })
                .is_some()
        })
        .ok_or_else(|| publication_input_error("continuation service roster overflow"))?;
    if capacity < 34 {
        return Err(publication_input_error(
            "continuation active capacity lacks its source and feedback slots",
        ));
    }
    let layout = |offset, scalar_type, element_bytes, rank, dimensions| {
        canonical_tensor_layout(SemanticTensorLayout {
            role: 0,
            index: first_index + offset,
            scalar_type,
            element_bytes,
            rank,
            dimensions,
            logical_axis: u64::MAX,
            strides_bytes: [0; 4],
        })
    };
    let mut layouts = vec![
        layout(0, 3, 8, 2, [32, 2, 0, 0])?,
        layout(1, 3, 8, 1, [1, 0, 0, 0])?,
        layout(2, 8, 1, 1, [32, 0, 0, 0])?,
        layout(3, 3, 8, 2, [capacity, 4, 0, 0])?,
        layout(4, 3, 8, 1, [1, 0, 0, 0])?,
        layout(5, 8, 1, 1, [1, 0, 0, 0])?,
    ];
    if let Some(blocks) = physical_blocks {
        layouts.push(layout(6, 9, 8, 3, [blocks as u64, 2, 3, 0])?);
    }
    Ok(layouts)
}

/// Decode the retained versioned schema from the original ModelContract slice.
fn retained_model_schema(
    record: &[u8],
    layout: SemanticModelContractLayout,
) -> Result<Option<serde_json::Value>, SemanticTransitionError> {
    layout.validate(record.len() as u64)?;
    let begin = layout.schema_begin as usize;
    let end = begin + layout.schema_bytes as usize;
    let Ok(schema) = serde_json::from_slice::<serde_json::Value>(&record[begin..end]) else {
        return Ok(None);
    };
    if schema
        .get("counter_encoding")
        .and_then(serde_json::Value::as_str)
        != Some("u32-hex8")
    {
        return Ok(None);
    }
    Ok(Some(schema))
}

/// Derive unique physical parameter owners from that same authenticated schema.
/// Other schema formats cannot claim this block-bound admission contract.
fn model_physical_parameter_roster(
    record: &[u8],
    layout: SemanticModelContractLayout,
) -> Result<Option<Vec<String>>, SemanticTransitionError> {
    let Some(schema) = retained_model_schema(record, layout)? else {
        return Ok(None);
    };
    let model = schema
        .get("model")
        .ok_or_else(|| publication_input_error("versioned model schema lacks its model owner"))?;
    let physical = model
        .get("physical")
        .and_then(serde_json::Value::as_object)
        .ok_or_else(|| publication_input_error("model schema lacks its physical owner roster"))?;
    let mut names = Vec::new();
    for (name, entry) in physical {
        match entry.get("kind").and_then(serde_json::Value::as_str) {
            Some("parameter") => names.push(name.clone()),
            Some("buffer") => {}
            _ => {
                return Err(publication_input_error(
                    "model physical roster has an unknown owner kind",
                ))
            }
        }
    }
    if names.is_empty() {
        return Err(publication_input_error(
            "model physical roster has no parameter owners",
        ));
    }
    names.sort_unstable();
    Ok(Some(names))
}

/// Identity of one packed active-cache row in its original forward. Kinds are
/// FILLED=1, MASK=2 and FEEDBACK=3; physical_row is not the packed coordinate.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticActiveRow {
    pub physical_row: u64,
    pub source_slot: u64,
    pub logical_position: u64,
    pub kind: u64,
}

/// Acquired bank-local active-cache state. A computed empty result has no rows
/// but is distinct from the initial parent which has never consumed a forward.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticActiveRows {
    pub computed: bool,
    pub rows: Vec<SemanticActiveRow>,
}

/// One original compact model row; source_slot is the acquired ring identity,
/// never the packed model coordinate. The row's array index identifies logits.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticTextRow {
    pub source_slot: u64,
    pub logical_position: u64,
}
// SAFETY: padding-free C representation containing only two initialized u64s.
unsafe impl DeviceRepr for SemanticTextRow {}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct TextBinding {
    rows: u64,
    count: u64,
    selected: u64,
}

struct TextBindingStorage {
    inputs: Vec<PreparedSemanticTensor>,
    numerical_block_snapshot: Option<Arc<TrackedCudaSlice<f64>>>,
    model_contract: Option<DeviceMemoryView<u8>>,
    physical_blocks: u64,
    model_schema_digest: Identity256,
    model_identity: Identity256,
    _witness: SemanticTensorContentWitness,
    _model_content_witness: Option<SemanticTensorContentWitness>,
    consumer_stream: u64,
    parent: TextBindingParent,
}

#[expect(
    clippy::large_enum_variant,
    reason = "the published header stays inline on the latency-sensitive export path"
)]
enum TextBindingParent {
    Published {
        bank: usize,
        header: PublicationHeader,
    },
    Prepared(Arc<PreparedStepInputs>),
}

impl TextBindingStorage {
    fn published_parent(&self) -> Result<(usize, PublicationHeader), SemanticTransitionError> {
        match &self.parent {
            TextBindingParent::Published { bank, header } => Ok((*bank, *header)),
            TextBindingParent::Prepared(_) => Err(publication_input_error(
                "a prepared invocation has no host-observed parent header",
            )),
        }
    }
    fn descriptor(&self) -> TextBinding {
        TextBinding {
            rows: self.inputs[0].data,
            count: self.inputs[1].data,
            selected: self.inputs[2].data,
        }
    }

    fn record(&self, recorder: &mut LaunchRecorder) {
        for input in &self.inputs {
            if let Some(source) = &input.source {
                recorder.read(source);
            }
        }
        if let Some(snapshot) = &self.numerical_block_snapshot {
            recorder.read(snapshot.as_ref());
        }
        if let Some(contract) = &self.model_contract {
            recorder.read(contract);
        }
    }

    fn continuation_inputs(
        &self,
        kind: SemanticTransitionKind,
        authority_bytes: u64,
        training_selection: u64,
        model_update: ModelUpdateContinuationInputs,
    ) -> ContinuationInputs {
        ContinuationInputs {
            text: self.descriptor(),
            active_rows: self.inputs[3].data,
            active_row_count: self.inputs[4].data,
            numerical_admissibility: self.inputs[5].data,
            numerical_blocks: self
                .numerical_block_snapshot
                .as_ref()
                .map_or(0, |snapshot| snapshot.device_ptr_value()),
            physical_blocks: self.physical_blocks,
            model_schema_digest: self.model_schema_digest,
            model_identity: self.model_identity,
            model_contract: self
                .model_contract
                .as_ref()
                .map_or(0, |contract| *contract.device_ptr()),
            model_contract_bytes: self
                .model_contract
                .as_ref()
                .map_or(0, |contract| contract.len() as u64),
            transition_kind: kind.code(),
            authority_bytes,
            training_selection,
            model_update_bindings: model_update.bindings,
            model_update_binding_count: model_update.binding_count,
            model_update_admissibility: model_update.admissibility,
            model_update_refusal: model_update.refusal,
            model_update_canary_results: model_update.canary_results,
        }
    }
}

fn enqueue_numerical_block_snapshot(
    domain: &ResidentExecutionDomain,
    poisoned: &mut bool,
    original: &PreparedSemanticTensor,
    destination: &TrackedCudaSlice<f64>,
) -> Result<(), SemanticTransitionError> {
    let source = original
        .source
        .as_ref()
        .ok_or_else(|| publication_input_error("original block bounds have no device storage"))?;
    let bytes = destination
        .len()
        .checked_mul(size_of::<f64>())
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    if source.len() != bytes {
        return Err(publication_input_error(
            "original block bounds differ from the frozen native capacity",
        ));
    }
    let mut recorder = domain.new_strict_recorder();
    recorder.read(source);
    recorder.write(destination);
    enqueue_recorded(domain, poisoned, recorder, |enqueue| {
        // SAFETY: the original typed witness established the exact contiguous
        // FP64 span and the destination is a disjoint native-owned allocation.
        unsafe {
            sys::cuMemcpyDtoDAsync_v2(
                destination.device_ptr_value(),
                *source.device_ptr(),
                bytes,
                enqueue.stream().cu_stream(),
            )
        }
        .result()
        .map_err(|error| XlogError::Kernel(format!("block bound snapshot: {error}")))
    })
}

/// Actual device-validated publication identity. This identifies content and
/// lineage; it is not a use-authority token or an externally issuable lease.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticPublishedIdentity {
    pub instance: Identity256,
    pub word: u64,
    pub logical_digest: Identity256,
    pub state_digest: Identity256,
}

/// Read-only identity projected from one fully validated original publication material.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticCheckpointNativeProjection {
    pub publication: SemanticPublishedIdentity,
    pub semantic_root: Identity256,
    pub model_generation: u64,
}

/// Read-only original inputs projected through the complete publication codec.
/// These content records are not proof of historical execution or use authority.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticPublicationInputProjection {
    pub publication: SemanticPublishedIdentity,
    pub semantic_root: Identity256,
    pub model_generation: u64,
    pub model_geometry_digest: Identity256,
    pub model_numerical_digest: Identity256,
    pub neural_generation: u64,
    pub cache_generation: u64,
    pub prefix_extent: u64,
    pub ring_head: u64,
    pub prefix_identity: Identity256,
    pub prefix: Vec<SemanticTextSlot>,
    pub source: [SemanticTextSlot; 32],
    pub token_provenance: Vec<SemanticTokenProvenance>,
    pub cache: Vec<SemanticPublicationTensorProjection>,
}

/// Original cache geometry and logical bytes under the native tensor seal.
/// Logical bytes exclude stride gaps and unused capacity, exactly as the seal does.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticPublicationTensorProjection {
    pub layout: SemanticTensorLayout,
    pub capacity_bytes: u64,
    pub logical_begin: u64,
    pub logical_end: u64,
    pub identity: Identity256,
    pub logical_bytes: Vec<u8>,
}

/// Original token origin projected from the native append-only source ledger.
/// A generated token retains its publication, draw and receipt coordinates;
/// none of these fields independently grants authority or proves publication.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticTokenProvenance {
    pub source_slot: u64,
    pub logical_position: u64,
    pub token: u64,
    pub base_word: u64,
    pub proposal: u64,
    pub ordinal: u64,
    pub action_receipt_digest: Identity256,
    pub authority_generation: u64,
    pub origin_logical_digest: Identity256,
    pub authority_closure_digest: Identity256,
    pub record_digest: Identity256,
}

/// Model metadata projected from one acquired publication, not supplied by the
/// model. Content identities grant no authority independently of that reader.
pub struct SemanticModelContext {
    pub parent: SemanticPublishedIdentity,
    pub descriptor_digest: Identity256,
    /// Original storage/view geometry and device-sealed numerical state. These
    /// do not replace the opaque ModelContract or grant independent authority.
    pub numerical_state: (Identity256, Identity256),
    pub semantic_root: (u64, u64, u64, Identity256, [u64; 3]),
    /// Original prefix identity U8[32] and committed extent U64[1] device views.
    pub prefix: (DlpackManagedTensor, DlpackManagedTensor),
    /// Original ring head U64[1], not a host scalar or a source rotation.
    pub ring_head: DlpackManagedTensor,
    /// Original source slots U64[32,8], in physical slot order.
    pub source: DlpackManagedTensor,
    /// Model generation, neural bank, neural generation, cache and authority.
    pub generations: (u64, u64, u64, u64, u64),
    pub topology_identity: Identity256,
    pub table_identity: Identity256,
    /// Prefix capacity, feedback capacity and exclusive position-table bound.
    pub capacities: (u64, u64, u64),
}

/// Direct read-only aliases of the selected resident neural bank. Each backing
/// allocation is exported exactly once; storages, views and layouts preserve
/// the producer's original alias geometry. The acquired reader remains the use
/// owner and therefore prevents reuse of this physical bank through final use.
pub struct SemanticResidentModelMemory {
    pub parent: SemanticPublishedIdentity,
    /// Model generation, neural bank and neural generation.
    pub generations: (u64, u64, u64),
    /// Original storage/view geometry and sealed numerical contents.
    pub numerical_state: (Identity256, Identity256),
    pub allocations: Vec<(DeviceAllocationProvenance, DlpackManagedTensor)>,
    pub storages: Vec<SemanticModelStorage>,
    pub views: Vec<(SemanticModelView, SemanticTensorLayout)>,
}

/// Admission cost of the next operation, checked against one acquired parent.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SemanticTransitionKind {
    Proposal,
    Recompute,
    Drain,
    Update,
}

impl SemanticTransitionKind {
    fn code(self) -> u64 {
        match self {
            Self::Proposal => 1,
            Self::Recompute => 2,
            Self::Drain => 3,
            Self::Update => 4,
        }
    }
}

fn is_tensor_role(role: u64) -> bool {
    matches!(role, 4..=13 | 18..=25 | 51..=54)
}

fn validate_publication_counts(counts: &[u64; 55]) -> Result<usize, SemanticTransitionError> {
    let mut total = 0u64;
    for (index, &count) in counts.iter().enumerate() {
        let role = index as u64 + 1;
        if (!is_tensor_role(role) && count != if role == 16 { 3 } else { 1 })
            || (matches!(role, 8..=13) && count != 1)
            || (role == 18 && count == 0)
        {
            return Err(publication_input_error(
                "publication role count omits or duplicates a required owner",
            ));
        }
        total = total
            .checked_add(count)
            .ok_or_else(|| publication_input_error("role count overflow"))?;
    }
    for (left, right) in [(4, 5), (6, 7), (4, 51), (5, 52), (6, 53), (7, 54)] {
        if counts[left - 1] != counts[right - 1] {
            return Err(publication_input_error(
                "paired cache and active tensor layer counts differ",
            ));
        }
    }
    usize::try_from(total).map_err(|_| publication_input_error("role count exceeds host extent"))
}

fn tensor_layout_bytes(layout: &SemanticTensorLayout) -> Result<usize, SemanticTransitionError> {
    if layout.rank > 4
        || !matches!(
            (layout.scalar_type, layout.element_bytes),
            (1, 1) | (2, 4) | (3, 8) | (4, 2) | (5, 2) | (6, 4) | (7, 8) | (8, 1) | (9, 8)
        )
        || (layout.logical_axis != u64::MAX && layout.logical_axis >= layout.rank)
        || layout.dimensions[layout.rank as usize..]
            .iter()
            .any(|&n| n != 0)
        || layout.strides_bytes[layout.rank as usize..]
            .iter()
            .any(|&n| n != 0)
    {
        return Err(publication_input_error(
            "invalid tensor rank, scalar type, or unused dimensions",
        ));
    }
    if layout.dimensions[..layout.rank as usize].contains(&0) {
        return Ok(0);
    }
    let mut axes: Vec<_> = (0..layout.rank as usize)
        .filter(|&i| layout.dimensions[i] > 1)
        .collect();
    axes.sort_by_key(|&i| layout.strides_bytes[i]);
    let mut span = layout.element_bytes;
    for axis in axes {
        let stride = layout.strides_bytes[axis];
        if stride < span || !stride.is_multiple_of(layout.element_bytes) {
            return Err(publication_input_error(
                "overlapping or unaligned tensor layout",
            ));
        }
        span = stride
            .checked_mul(layout.dimensions[axis] - 1)
            .and_then(|n| span.checked_add(n))
            .ok_or_else(|| publication_input_error("tensor byte extent overflow"))?;
    }
    usize::try_from(span).map_err(|_| publication_input_error("tensor extent exceeds host size"))
}

fn empty_model_tensor_layout(layout: &SemanticTensorLayout) -> bool {
    matches!(layout.role, 18..=25)
        && layout.logical_axis == u64::MAX
        && tensor_layout_bytes(layout).is_ok_and(|bytes| bytes == 0)
}

fn prefix_capacity_layout(
    mut layout: SemanticTensorLayout,
    capacity: u64,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    if !matches!(layout.role, 4 | 5)
        || layout.rank != 4
        || layout.logical_axis != 2
        || layout.dimensions[0] != 1
        || layout.dimensions[2] > capacity
    {
        return Err(publication_input_error(
            "prefix cache layout must be batch-one rank-four with position axis two",
        ));
    }
    layout.dimensions[2] = capacity;
    canonical_tensor_layout(layout)
}

fn canonical_tensor_layout(
    mut layout: SemanticTensorLayout,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    if layout.rank > 4 {
        return Err(publication_input_error("canonical tensor rank is invalid"));
    }
    let mut stride = layout.element_bytes;
    for axis in (0..layout.rank as usize).rev() {
        layout.strides_bytes[axis] = stride;
        stride = stride
            .checked_mul(layout.dimensions[axis].max(1))
            .ok_or_else(|| publication_input_error("canonical tensor stride overflow"))?;
    }
    tensor_layout_bytes(&layout)?;
    Ok(layout)
}

fn validate_active_capacity(
    layout: &SemanticTensorLayout,
    capacity: u64,
) -> Result<(), SemanticTransitionError> {
    tensor_layout_bytes(layout)?;
    let axis = if matches!(layout.role, 51 | 52) {
        if layout.rank != 4 || layout.dimensions[0] != 1 {
            return Err(publication_input_error(
                "active attention must be batch-one rank-four",
            ));
        }
        2
    } else if matches!(layout.role, 53 | 54) {
        0
    } else {
        return Err(publication_input_error(
            "active capacity requires an active tensor role",
        ));
    };
    if layout.logical_axis != axis
        || layout.dimensions[axis as usize] != capacity
        || capacity == 0
        || layout.dimensions[..layout.rank as usize].contains(&0)
        || !matches!(layout.scalar_type, 4..=6)
    {
        return Err(publication_input_error(
            "active tensor row axis must have the exact window plus feedback capacity",
        ));
    }
    Ok(())
}

fn continuation_capacity_layout(
    mut model: SemanticTensorLayout,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    tensor_layout_bytes(&model)?;
    if !continuation_role(model.role) || !is_tensor_role(model.role) {
        return Err(publication_input_error(
            "continuation layout has no forward tensor owner",
        ));
    }
    let active = matches!(model.role, 51..=54);
    let suffix = matches!(model.role, 4 | 5);
    let axis = if active {
        if matches!(model.role, 51 | 52) {
            2
        } else {
            0
        }
    } else if suffix {
        2
    } else {
        u64::MAX
    };
    if model.logical_axis != axis || (axis != u64::MAX && axis >= model.rank) {
        return Err(publication_input_error(
            "continuation tensor has the wrong original row axis",
        ));
    }
    if suffix {
        model.dimensions[2] = 0;
        prefix_capacity_layout(model, 32)
    } else {
        canonical_tensor_layout(model)
    }
}

fn continuation_allocation_layout(
    model: SemanticTensorLayout,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    continuation_capacity_layout(model)?;
    if matches!(model.role, 4 | 5) {
        canonical_tensor_layout(model)
    } else {
        continuation_capacity_layout(model)
    }
}

fn continuation_tensor_layout_for_kind(
    actual: &SemanticTensorLayout,
    begin: u64,
    end: u64,
    model: &SemanticTensorLayout,
    kind: SemanticTransitionKind,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    if kind != SemanticTransitionKind::Update || !matches!(model.role, 4 | 5) {
        return continuation_tensor_layout(actual, begin, end, model);
    }
    let expected = canonical_tensor_layout(*model)?;
    let destination = canonical_tensor_layout(*actual)?;
    if destination != expected {
        return Err(publication_input_error(
            "continuation tensor differs from its transition-specific fixed-capacity layout",
        ));
    }
    tensor_layout_bytes(actual)?;
    let capacity = if expected.logical_axis == u64::MAX {
        0
    } else {
        expected.dimensions[expected.logical_axis as usize]
    };
    if (begin, end) != (0, capacity) {
        return Err(publication_input_error(
            "continuation transport differs from its transition-specific fixed-capacity output",
        ));
    }
    Ok(destination)
}

fn continuation_tensor_layout(
    actual: &SemanticTensorLayout,
    begin: u64,
    end: u64,
    model: &SemanticTensorLayout,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    let expected = continuation_capacity_layout(*model)?;
    let destination = canonical_tensor_layout(*actual)?;
    if destination != expected {
        return Err(publication_input_error(
            "continuation tensor differs from its cold fixed-capacity layout",
        ));
    }
    // Validate original strides too: canonicalization must not conceal an
    // invalid producer view before the recorded device-to-device snapshot.
    tensor_layout_bytes(actual)?;
    let capacity = if expected.logical_axis == u64::MAX {
        0
    } else {
        expected.dimensions[expected.logical_axis as usize]
    };
    if (begin, end) != (0, capacity) {
        return Err(publication_input_error(
            "continuation transport differs from its original fixed-capacity output",
        ));
    }
    Ok(destination)
}

/// Cold copy geometry only: no tensor value is inspected or copied through host memory.
fn tensor_copy_plan(
    source: &SemanticTensorLayout,
    destination: &SemanticTensorLayout,
) -> Result<Vec<(u64, u64, usize)>, SemanticTransitionError> {
    tensor_layout_bytes(source)?;
    tensor_layout_bytes(destination)?;
    if source.rank != destination.rank
        || source.scalar_type != destination.scalar_type
        || source.element_bytes != destination.element_bytes
        || (0..source.rank as usize)
            .any(|axis| source.dimensions[axis] > destination.dimensions[axis])
    {
        return Err(publication_input_error(
            "tensor snapshot layout does not fit its owned destination",
        ));
    }
    if source.dimensions[..source.rank as usize].contains(&0) {
        return Ok(Vec::new());
    }
    let mut first_outer = source.rank as usize;
    let mut chunk = source.element_bytes;
    while first_outer > 0 {
        let axis = first_outer - 1;
        if source.strides_bytes[axis] != chunk || destination.strides_bytes[axis] != chunk {
            break;
        }
        chunk = chunk
            .checked_mul(source.dimensions[axis])
            .ok_or_else(|| publication_input_error("copy chunk overflow"))?;
        first_outer = axis;
    }
    let count = source.dimensions[..first_outer]
        .iter()
        .try_fold(1u64, |count, &dim| count.checked_mul(dim))
        .ok_or_else(|| publication_input_error("copy row count overflow"))?;
    let mut result = Vec::new();
    result
        .try_reserve(
            usize::try_from(count)
                .map_err(|_| publication_input_error("copy row count exceeds host extent"))?,
        )
        .map_err(|error| runtime_error("copy plan allocation", error))?;
    for mut linear in 0..count {
        let (mut source_offset, mut destination_offset) = (0u64, 0u64);
        for axis in (0..first_outer).rev() {
            let position = linear % source.dimensions[axis];
            linear /= source.dimensions[axis];
            source_offset += position * source.strides_bytes[axis];
            destination_offset += position * destination.strides_bytes[axis];
        }
        result.push((source_offset, destination_offset, chunk as usize));
    }
    Ok(result)
}

#[derive(Clone, Copy)]
struct TensorMetadata<'a> {
    device_type: i32,
    device_id: i32,
    dtype: crate::dlpack::DLDataType,
    shape: &'a [i64],
    strides: Option<&'a [i64]>,
    data: u64,
    byte_offset: u64,
}

// SAFETY: the caller retains the genuine managed producer and its immutable
// shape/stride arrays for the returned borrow. A scalar has no shape entries;
// its DLPack shape and strides may be null and must never form a raw Rust slice.
unsafe fn semantic_tensor_metadata(
    actual: &crate::dlpack::DLTensor,
) -> Result<TensorMetadata<'_>, SemanticTransitionError> {
    if !(0..=4).contains(&actual.ndim) || (actual.ndim != 0 && actual.shape.is_null()) {
        return Err(publication_input_error(
            "semantic tensor requires an original scalar through rank-four shape",
        ));
    }
    let rank = actual.ndim as usize;
    Ok(TensorMetadata {
        device_type: actual.device.device_type,
        device_id: actual.device.device_id,
        dtype: actual.dtype,
        // SAFETY: a nonempty shape was checked above and is owned by the caller.
        shape: if rank == 0 {
            &[]
        } else {
            unsafe { std::slice::from_raw_parts(actual.shape, rank) }
        },
        strides: if rank == 0 || actual.strides.is_null() {
            None
        } else {
            // SAFETY: DLPack's retained producer owns ndim stride elements.
            Some(unsafe { std::slice::from_raw_parts(actual.strides, rank) })
        },
        data: actual.data as usize as u64,
        byte_offset: actual.byte_offset,
    })
}

fn publication_input_error(detail: &str) -> SemanticTransitionError {
    SemanticTransitionError::InvalidInput {
        detail: detail.into(),
    }
}

fn validate_tensor_metadata(
    declared: &SemanticTensorLayout,
    actual: &TensorMetadata<'_>,
    device_id: i32,
) -> Result<(u64, usize), SemanticTransitionError> {
    let invalid = || {
        publication_input_error("semantic tensor metadata differs from its exact model contract")
    };
    let (dtype_code, bits) = match declared.scalar_type {
        1 => (crate::dlpack::K_DLUINT, 8),
        2 => (crate::dlpack::K_DLUINT, 32),
        3 => (crate::dlpack::K_DLUINT, 64),
        4 => (crate::dlpack::K_DLFLOAT, 16),
        5 => (4, 16), // DLPack's distinct bfloat type code, not IEEE float16.
        6 => (crate::dlpack::K_DLFLOAT, 32),
        7 => (0, 64), // Signed token indices are not unsigned storage aliases.
        8 => (6, 8),  // DLPack's distinct Boolean code.
        9 => (crate::dlpack::K_DLFLOAT, 64),
        _ => return Err(invalid()),
    };
    let rank = actual.shape.len();
    if actual.device_type != crate::dlpack::K_DLCUDA
        || actual.device_id != device_id
        || rank > 4
        || declared.rank != rank as u64
        || actual.dtype.code != dtype_code
        || actual.dtype.bits != bits
        || actual.dtype.lanes != 1
        || declared.element_bytes != u64::from(bits / 8)
        || (declared.role != 0 && SemanticStateRole::from_code(declared.role).is_none())
        || (declared.logical_axis != u64::MAX && declared.logical_axis >= declared.rank)
        || declared.dimensions[rank..]
            .iter()
            .any(|&dimension| dimension != 0)
        || declared.strides_bytes[rank..]
            .iter()
            .any(|&stride| stride != 0)
    {
        return Err(invalid());
    }
    let element_bytes = declared.element_bytes;
    let mut dimensions = [0u64; 4];
    for (index, &dimension) in actual.shape.iter().enumerate() {
        dimensions[index] = u64::try_from(dimension).map_err(|_| invalid())?;
    }
    if dimensions != declared.dimensions {
        return Err(invalid());
    }
    let mut strides = [0u64; 4];
    if let Some(actual_strides) = actual.strides {
        if actual_strides.len() != rank {
            return Err(invalid());
        }
        for (index, &stride) in actual_strides.iter().enumerate() {
            strides[index] = u64::try_from(stride)
                .ok()
                .and_then(|stride| stride.checked_mul(element_bytes))
                .ok_or_else(invalid)?;
        }
    } else {
        let mut stride = element_bytes;
        for index in (0..rank).rev() {
            strides[index] = stride;
            stride = stride.checked_mul(dimensions[index]).ok_or_else(invalid)?;
        }
    }
    if strides != declared.strides_bytes {
        return Err(invalid());
    }
    let empty = dimensions[..rank].contains(&0);
    let bytes = if empty {
        0
    } else {
        // Positive non-overlapping strides support real transposed and padded
        // views. Broadcast/overlapping cells are not a mutable state contract.
        let mut axes = (0..rank)
            .filter(|&axis| dimensions[axis] > 1)
            .collect::<Vec<_>>();
        axes.sort_by_key(|&axis| strides[axis]);
        let mut span = element_bytes;
        for axis in axes {
            if strides[axis] < span {
                return Err(invalid());
            }
            span = strides[axis]
                .checked_mul(dimensions[axis] - 1)
                .and_then(|bytes| span.checked_add(bytes))
                .ok_or_else(invalid)?;
        }
        span
    };
    if !actual.byte_offset.is_multiple_of(element_bytes) || (bytes != 0 && actual.data == 0) {
        return Err(invalid());
    }
    let pointer = actual
        .data
        .checked_add(actual.byte_offset)
        .ok_or_else(invalid)?;
    if !pointer.is_multiple_of(element_bytes) || pointer.checked_add(bytes).is_none() {
        return Err(invalid());
    }
    let bytes = usize::try_from(bytes).map_err(|_| invalid())?;
    usize::try_from(pointer).map_err(|_| invalid())?;
    Ok((pointer, bytes))
}

#[derive(Clone)]
struct PreparedSemanticTensor {
    layout: SemanticTensorLayout,
    logical_begin: u64,
    logical_end: u64,
    data: u64,
    source: Option<DeviceMemoryView<u8>>,
    native_allocation: Option<DeviceAllocationProvenance>,
    // Empty views still retain their genuine producer; releasing its token can
    // retire a larger backing allocation whose producer work is still pending.
    _empty_owner: Option<Arc<DlpackManagedTensor>>,
}

#[cfg(feature = "semantic-policy")]
unsafe fn policy_score_cotangent_metadata(
    actual: &crate::dlpack::DLTensor,
    device_id: i32,
) -> Result<(u64, usize), SemanticTransitionError> {
    // SAFETY: the caller retains the original shape/stride descriptor arrays.
    let (rows, scalar, data, bytes) =
        unsafe { crate::dlpack::dlpack_tensor_metadata(device_id, actual) }.map_err(|error| {
            publication_input_error(&format!("selected-score cotangent metadata: {error}"))
        })?;
    if rows != COMPONENT_COUNT as u64
        || scalar != xlog_core::ScalarType::F64
        || data.checked_add(bytes as u64).is_none()
    {
        return Err(publication_input_error(
            "selected-score cotangents require exact contiguous FP64 storage",
        ));
    }
    Ok((data, bytes))
}

struct RetainedTensorAdmission<T: Send + 'static> {
    inputs: Option<Vec<T>>,
    stream: Arc<CudaStream>,
    ready: bool,
}

impl<T: Send + 'static> Drop for RetainedTensorAdmission<T> {
    fn drop(&mut self) {
        let Some(inputs) = self.inputs.take() else {
            return;
        };
        if self.ready {
            drop(inputs);
            return;
        }
        // Preserve the genuine producer tokens through a failed/unknown cold
        // handoff. Canonical retirement retries readiness and runs deleters once.
        crate::cuda_graph::retire_resources_after_completion(
            (Some(inputs), Arc::clone(&self.stream)),
            |owners| owners.1.synchronize(),
            |owners| {
                drop(owners.0.take());
                Ok(())
            },
            |_| Ok(()),
            |_, error| eprintln!("semantic tensor producer retirement incomplete: {error}"),
        );
    }
}

// Metadata/ownership admission only. The caller must order producer readiness
// before reading any device cells; cold import above waits, content guards use
// device event edges and retain all owners until explicit reader release.
fn prepare_semantic_tensors(
    provider: &CudaKernelProvider,
    inputs: Vec<SemanticTensorInput>,
) -> Result<Vec<PreparedSemanticTensor>, SemanticTransitionError> {
    let stream = Arc::clone(provider.device().inner().stream());
    let mut pending = RetainedTensorAdmission {
        inputs: Some(inputs),
        stream: Arc::clone(&stream),
        ready: false,
    };
    let mut geometry = Vec::new();
    for input in pending
        .inputs
        .as_ref()
        .expect("retained original producer roster")
    {
        let pointer = input.tensor.as_ptr();
        if pointer.is_null() {
            return Err(publication_input_error(
                "semantic tensor managed owner is null",
            ));
        }
        // SAFETY: the genuine managed producer owns valid immutable DLPack
        // metadata for this import. Rank is bounded before reading its arrays;
        // the caller owns the managed record and orders its producer before use.
        let actual = unsafe { &(*pointer).dl_tensor };
        // SAFETY: the complete original producer roster remains in pending.
        let metadata = unsafe { semantic_tensor_metadata(actual) }?;
        let (data, bytes) =
            validate_tensor_metadata(&input.layout, &metadata, provider.device().ordinal() as i32)?;
        geometry.push((data, bytes));
    }
    // Every fallible metadata check precedes transfer of any original owner.
    // Failure retires the complete producer roster on its negotiated stream.
    // Success transfers ownership to the views, without a host wait.
    pending.ready = true;
    let inputs = pending
        .inputs
        .take()
        .expect("retained original producer roster");
    let mut imported = Vec::with_capacity(inputs.len());
    for (input, (data, bytes)) in inputs.into_iter().zip(geometry) {
        let (source, empty_owner) = if bytes == 0 {
            // No invented device cells, but keep the actual managed owner until
            // the caller's cold completion or content-reader retirement.
            (None, Some(Arc::new(input.tensor)))
        } else {
            // SAFETY: exact original dtype/shape/stride/offset/device bounds and
            // producer readiness ordering is the caller's responsibility. This is the
            // canonical managed owner, not a borrowed raw-pointer slice.
            let column =
                unsafe { CudaColumn::dlpack(data, bytes, Arc::clone(&stream), input.tensor) };
            (Some(column.device_view()), None)
        };
        imported.push(PreparedSemanticTensor {
            layout: input.layout,
            logical_begin: input.logical_begin,
            logical_end: input.logical_end,
            data,
            source,
            native_allocation: input.native_allocation,
            _empty_owner: empty_owner,
        });
    }
    Ok(imported)
}

fn complete_tensor_handoff<T: Send + 'static>(
    provider: &CudaKernelProvider,
    inputs: Vec<T>,
) -> Result<Vec<T>, SemanticTransitionError> {
    let stream = Arc::clone(provider.device().inner().stream());
    let mut pending = RetainedTensorAdmission {
        inputs: Some(inputs),
        stream,
        ready: false,
    };
    let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&pending.stream)
        .map_err(|error| runtime_error("tensor producer stream admission", error))?;
    pending
        .stream
        .synchronize()
        .map_err(|error| runtime_error("tensor producer handoff", error))?;
    pending.ready = true;
    Ok(pending
        .inputs
        .take()
        .expect("retained tensor admission owns its inputs"))
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationStorageEntry {
    pointer: u64,
    bytes: u64,
    generation: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationRange {
    role: u64,
    index: u64,
    storage_slot: u64,
    generation: u64,
    offset_bytes: u64,
    length_bytes: u64,
    logical_begin: u64,
    logical_end: u64,
    digest: Identity256,
    backing_digest: Identity256,
}

/// Descriptor integrity includes local handles; logical content identities do
/// not. Every physical range resolves through the owner's fixed storage table.
#[repr(C)]
#[derive(Clone, Copy, Default, PartialEq, Eq)]
struct PublicationHeader {
    abi: u64,
    instance: Identity256,
    recovered_instance: Identity256,
    sealed_epoch: u64,
    base_word: u64,
    publication_word: u64,
    ring_head: u64,
    prefix_extent: u64,
    semantic_owner: u64,
    semantic_slot: u64,
    semantic_generation: u64,
    semantic_digest: Identity256,
    semantic_extents: [u64; 3],
    model_generation: u64,
    neural_bank: u64,
    neural_generation: u64,
    cache_generation: u64,
    authority_generation: u64,
    terminal: u64,
    terminal_position: u64,
    fuel: u64,
    proposal: u64,
    stream_serial: u64,
    family_id: u64,
    training_cursor: u64,
    training_rng: [u64; 4],
    range_count: u64,
    model_geometry_digest: Identity256,
    model_numerical_digest: Identity256,
    logical_digest: Identity256,
    state_digest: Identity256,
    descriptor_digest: Identity256,
}

impl PublicationHeader {
    fn rng_binding(&self) -> Result<SemanticRngBinding, SemanticTransitionError> {
        if self.stream_serial > u64::MAX >> 8 {
            return Err(SemanticTransitionError::GenerationExhausted);
        }
        Ok(SemanticRngBinding {
            model_generation: u32::try_from(self.model_generation)
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
            family_id: u8::try_from(self.family_id)
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
            stream_serial: self.stream_serial,
            proposal: u32::try_from(self.proposal)
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
        })
    }
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationControl {
    abi: u64,
    word: u64,
    instance: Identity256,
    banks: [u64; 2],
    directories: [u64; 2],
    storage: u64,
    storage_count: u64,
    contract: u64,
    continuation: u64,
    reader_counts: [u64; 2],
    reader_gate: u64,
    refusal: u64,
}

#[repr(C)]
#[derive(Clone, Copy)]
struct PublicationBank {
    header: PublicationHeader,
    source: [SourceSlot; 32],
    state: DeviceState,
    receipts: [SemanticTransitionReceipt; COMPONENT_COUNT],
}

#[derive(Clone, Copy)]
enum PublicationBankField {
    Source,
    PrefixExtent,
    RingHead,
    Terminal,
}

impl PublicationBankField {
    fn layout(self) -> (std::ops::Range<usize>, Vec<i64>, Vec<i64>) {
        let (offset, bytes, shape, strides) = match self {
            Self::Source => (
                std::mem::offset_of!(PublicationBank, source),
                size_of::<[SourceSlot; 32]>(),
                vec![32, 8],
                vec![8, 1],
            ),
            Self::PrefixExtent => (
                std::mem::offset_of!(PublicationBank, header)
                    + std::mem::offset_of!(PublicationHeader, prefix_extent),
                size_of::<u64>(),
                vec![1],
                vec![1],
            ),
            Self::RingHead => (
                std::mem::offset_of!(PublicationBank, header)
                    + std::mem::offset_of!(PublicationHeader, ring_head),
                size_of::<u64>(),
                vec![1],
                vec![1],
            ),
            Self::Terminal => (
                std::mem::offset_of!(PublicationBank, header)
                    + std::mem::offset_of!(PublicationHeader, terminal),
                size_of::<u64>(),
                vec![1],
                vec![1],
            ),
        };
        (offset..offset + bytes, shape, strides)
    }
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationRoleCount {
    role: u64,
    count: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationContract {
    abi: u64,
    range_capacity: u64,
    prefix_capacity: u64,
    window_capacity: u64,
    feedback_capacity: u64,
    max_position: u64,
    pad_token: u64,
    terminal_tokens: u64,
    terminal_token_count: u64,
    final_intent_payload_bytes: u64,
    model_generation: u64,
    policy_generation: u64,
    authority_generation: u64,
    semantic_owner: u64,
    task_identity: Identity256,
    topology_identity: Identity256,
    table_identity: Identity256,
    role_counts: u64,
    role_count: u64,
    model_contract_layout: SemanticModelContractLayout,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PendingContinuation {
    abi: u64,
    instance: Identity256,
    base_word: u64,
    model_generation: u64,
    authority_generation: u64,
    topology_identity: Identity256,
    table_identity: Identity256,
    prefix_identity: Identity256,
    ranges: u64,
    range_count: u64,
    transition_kind: u64,
    text: TextBinding,
    numerical_admissibility: u64,
    training_selection: u64,
    model_update_bindings: u64,
    model_update_binding_count: u64,
    model_update_admissibility: u64,
    model_update_refusal: u64,
    model_update_canary_results: u64,
    numerical_blocks: u64,
    physical_blocks: u64,
    model_schema_digest: Identity256,
    model_identity: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy)]
struct ContinuationInputs {
    text: TextBinding,
    active_rows: u64,
    active_row_count: u64,
    numerical_admissibility: u64,
    transition_kind: u64,
    authority_bytes: u64,
    training_selection: u64,
    model_update_bindings: u64,
    model_update_binding_count: u64,
    model_update_admissibility: u64,
    model_update_refusal: u64,
    model_update_canary_results: u64,
    numerical_blocks: u64,
    physical_blocks: u64,
    model_schema_digest: Identity256,
    model_identity: Identity256,
    model_contract: u64,
    model_contract_bytes: u64,
}

#[derive(Clone, Copy, Default)]
struct ModelUpdateContinuationInputs {
    bindings: u64,
    binding_count: u64,
    admissibility: u64,
    refusal: u64,
    canary_results: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelUpdateBinding {
    source: u64,
    bytes: u64,
    slots: [u64; 2],
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelUpdateEvidenceSource {
    lease: u64,
    parent_header: u64,
    result: u64,
    origin: u64,
    states: [u64; 2],
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelForwardSealInput {
    role: u64,
    index: u64,
    tensor_digest: u64,
    backing_digest: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelForwardReceipt {
    abi: u64,
    availability: u64,
    role: u64,
    generation: u64,
    work_sequence: u64,
    logits: u64,
    scalar_type: u64,
    row_count: u64,
    capacity: u64,
    vocabulary: u64,
    strides_bytes: [u64; 3],
    model_geometry_digest: Identity256,
    model_numerical_digest: Identity256,
    logits_digest: Identity256,
    identity: Identity256,
}

#[cfg(feature = "semantic-policy")]
impl ModelForwardReceipt {
    fn canonical_bytes(&self) -> Vec<u8> {
        let mut bytes = Vec::with_capacity(size_of::<Self>());
        for word in [
            self.abi,
            self.availability,
            self.role,
            self.generation,
            self.work_sequence,
            self.logits,
            self.scalar_type,
            self.row_count,
            self.capacity,
            self.vocabulary,
        ]
        .into_iter()
        .chain(self.strides_bytes)
        {
            bytes.extend_from_slice(&word.to_le_bytes());
        }
        for identity in [
            self.model_geometry_digest,
            self.model_numerical_digest,
            self.logits_digest,
            self.identity,
        ] {
            bytes.extend_from_slice(identity.as_bytes());
        }
        bytes
    }
}

/// Original completed forward receipt, copied cold without retaining CUDA aliases.
#[cfg(feature = "semantic-policy")]
#[derive(Clone, Debug)]
pub struct SemanticUpdateForwardReceipt {
    pub availability: u64,
    /// None only when the original producer did not obtain a complete receipt.
    pub material: Option<SemanticUpdateForwardReceiptMaterial>,
}

#[cfg(feature = "semantic-policy")]
#[derive(Clone, Debug)]
pub struct SemanticUpdateForwardReceiptMaterial {
    pub role: u64,
    pub generation: u64,
    pub work_sequence: u64,
    pub scalar_type: u64,
    pub dimensions: [u64; 3],
    pub strides_bytes: [u64; 3],
    pub model_geometry_digest: Identity256,
    pub model_numerical_digest: Identity256,
    pub logits_digest: Identity256,
    pub identity: Identity256,
    /// Exact private receipt words, including the original pointer value as data,
    /// not a live address or execution grant. Its SHA-256 seal is the final 32 bytes.
    pub canonical_bytes: Vec<u8>,
}

/// A frozen check and its device-authored execution/measurement availability.
#[cfg(feature = "semantic-policy")]
#[derive(Clone, Debug)]
pub struct SemanticUpdateCanaryMeasurement {
    pub frozen: crate::SemanticTrainingCanaryRecord,
    pub protected_positions: Vec<u64>,
    pub availability: u64,
    pub reason: u64,
    pub measurement_bits: Option<u64>,
    pub memory_used: u64,
    pub work_used: u64,
}

/// Cold original Update observations. Acceptance is independent of availability.
#[cfg(feature = "semantic-policy")]
#[derive(Clone, Debug)]
pub struct SemanticUpdateMeasurements {
    pub predecessor: SemanticPublishedIdentity,
    pub successor: Option<SemanticPublishedIdentity>,
    pub bank: u8,
    pub model_generation: u64,
    pub model_geometry_digest: Identity256,
    pub model_numerical_digest: Identity256,
    pub transition_status: u64,
    pub selection: SemanticTrainingViewSelection,
    pub canaries: Vec<SemanticUpdateCanaryMeasurement>,
    pub forward_receipts: [SemanticUpdateForwardReceipt; 2],
    pub canary_refusal: Option<SemanticTrainingCanaryRefusalRecord>,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelForwardReceiptInputs {
    control: u64,
    lease: u64,
    candidate_seals: u64,
    candidate_seal_count: u64,
    role: u64,
    work_sequence: u64,
    logits: u64,
    scalar_type: u64,
    row_count: u64,
    capacity: u64,
    vocabulary: u64,
    row_stride_bytes: u64,
    position_stride_bytes: u64,
    vocabulary_stride_bytes: u64,
    logits_digest: u64,
    receipt: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationCommand {
    control: u64,
    lease: u64,
    operation: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationDeliveryInput {
    lease: u64,
    receipt: u64,
    receipt_len: u64,
    recipient_id: Identity256,
    receipt_digest: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PublicationLease {
    abi: u64,
    status: u64,
    instance: Identity256,
    word: u64,
    bank: u64,
    epoch: u64,
    active: u64,
    transition_kind: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct CompletionCoverage {
    abi: u64,
    instance: Identity256,
    base_word: u64,
    model_generation: u64,
    topology_identity: Identity256,
    table_identity: Identity256,
    prefix_identity: Identity256,
    prefix_begin: u64,
    prefix_end: u64,
    source_digest: Identity256,
    attention_digest: Identity256,
    linear_digest: Identity256,
    value_digest: Identity256,
    edit_digest: Identity256,
    receipt_digest: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy)]
struct RawFeedbackRecord {
    valid: u64,
    statement_index: u64,
    statement_offset_bytes: u64,
    statement_length_bytes: u64,
    pro: u64,
    contra: u64,
    query_receipt: [u64; 42],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct AttemptReceipt {
    abi: u64,
    transition_kind: u64,
    instance: Identity256,
    base_word: u64,
    next_word: u64,
    logical_digest: Identity256,
    action_receipts_digest: Identity256,
    semantic_receipts_digest: Identity256,
    coverage_digest: Identity256,
    replay_head_digest: Identity256,
    intent_head_digest: Identity256,
    acknowledgement_head_digest: Identity256,
    previous_attempt_digest: Identity256,
    receipt_digest: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct IntentQueueHeader {
    abi: u64,
    count: u64,
    capacity: u64,
    payload_used_bytes: u64,
    payload_capacity_bytes: u64,
    effect_offset_bytes: u64,
    effect_length_bytes: u64,
    chain_head: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct IntentEntry {
    stable_identity: Identity256,
    checkpoint_lineage: Identity256,
    base_logical: Identity256,
    effective_delta: Identity256,
    result_logical: Identity256,
    effect_digest: Identity256,
    payload_digest: Identity256,
    payload_offset: u64,
    payload_len: u64,
    audit_instance: Identity256,
    audit_epoch: u64,
    previous_chain: Identity256,
    chain: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct AcknowledgementQueueHeader {
    abi: u64,
    count: u64,
    capacity: u64,
    payload_used_bytes: u64,
    payload_capacity_bytes: u64,
    chain_head: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct AcknowledgementEntry {
    stable_identity: Identity256,
    receipt_digest: Identity256,
    receipt_len: u64,
    previous_chain: Identity256,
    chain: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct TokenProvenance {
    source_slot: u64,
    logical_position: u64,
    token: u64,
    base_word: u64,
    proposal: u64,
    ordinal: u64,
    action_receipt_digest: Identity256,
    authority_generation: u64,
    origin_logical_digest: Identity256,
    authority_closure_digest: Identity256,
    record_digest: Identity256,
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticTensorLayout {
    pub role: u64,
    pub index: u64,
    pub element_bytes: u64,
    // U8, U32, U64, F16, BF16, F32, I64, Bool8 respectively.
    // Equal widths are not equal types.
    pub scalar_type: u64,
    pub rank: u64,
    pub logical_axis: u64,
    pub dimensions: [u64; 4],
    pub strides_bytes: [u64; 4],
}

#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct TensorLayoutTableHeader {
    abi: u64,
    layout_count: u64,
    active_computed: u64,
    active_row_count: u64,
}

fn tensor_table_capacity(
    layout_count: usize,
    row_count: u64,
) -> Result<usize, SemanticTransitionError> {
    layout_count
        .checked_mul(size_of::<SemanticTensorLayout>())
        .and_then(|n| n.checked_add(size_of::<TensorLayoutTableHeader>()))
        .and_then(|n| {
            usize::try_from(row_count)
                .ok()?
                .checked_mul(size_of::<SemanticActiveRow>())?
                .checked_add(n)
        })
        .ok_or_else(|| publication_input_error("tensor layout table extent overflow"))
}

fn tensor_table_bytes(
    layouts: &[SemanticTensorLayout],
    computed: bool,
    rows: &[SemanticActiveRow],
) -> Result<Vec<u8>, SemanticTransitionError> {
    if !computed && !rows.is_empty() {
        return Err(publication_input_error(
            "uncomputed active cache cannot contain rows",
        ));
    }
    let length = tensor_table_capacity(layouts.len(), rows.len() as u64)?;
    let mut bytes = Vec::new();
    bytes
        .try_reserve_exact(length)
        .map_err(|error| runtime_error("tensor layout table allocation", error))?;
    bytes.extend(publication_abi_bytes(&[TensorLayoutTableHeader {
        abi: 1,
        layout_count: layouts.len() as u64,
        active_computed: u64::from(computed),
        active_row_count: rows.len() as u64,
    }]));
    bytes.extend(publication_abi_bytes(layouts));
    bytes.extend(publication_abi_bytes(rows));
    Ok(bytes)
}

fn decode_tensor_table(
    bytes: &[u8],
) -> Result<
    (
        TensorLayoutTableHeader,
        Vec<SemanticTensorLayout>,
        SemanticActiveRows,
    ),
    SemanticTransitionError,
> {
    if bytes.len() < size_of::<TensorLayoutTableHeader>() {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    // SAFETY: checked complete integer-only header; byte storage need not align.
    let header = unsafe {
        bytes
            .as_ptr()
            .cast::<TensorLayoutTableHeader>()
            .read_unaligned()
    };
    let count = usize::try_from(header.layout_count)
        .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
    if header.abi != 1
        || header.active_computed > 1
        || (header.active_computed == 0 && header.active_row_count != 0)
        || tensor_table_capacity(count, header.active_row_count)? != bytes.len()
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let layouts_end =
        size_of::<TensorLayoutTableHeader>() + count * size_of::<SemanticTensorLayout>();
    let layouts = bytes[size_of::<TensorLayoutTableHeader>()..layouts_end]
        .as_chunks::<{ size_of::<SemanticTensorLayout>() }>()
        .0
        .iter()
        // SAFETY: each chunk is a complete integer-only C record.
        .map(|chunk| unsafe {
            chunk
                .as_ptr()
                .cast::<SemanticTensorLayout>()
                .read_unaligned()
        })
        .collect();
    let rows = bytes[layouts_end..]
        .as_chunks::<{ size_of::<SemanticActiveRow>() }>()
        .0
        .iter()
        // SAFETY: each chunk is a complete integer-only C record.
        .map(|chunk| unsafe { chunk.as_ptr().cast::<SemanticActiveRow>().read_unaligned() })
        .collect();
    Ok((
        header,
        layouts,
        SemanticActiveRows {
            computed: header.active_computed == 1,
            rows,
        },
    ))
}

// SAFETY: these C-layout records contain only integers, fixed byte arrays and
// the already checked scalar state/receipt ABI. Every bit pattern is valid.
unsafe impl DeviceRepr for PublicationStorageEntry {}
unsafe impl DeviceRepr for PublicationRange {}
unsafe impl DeviceRepr for PublicationHeader {}
unsafe impl DeviceRepr for PublicationControl {}
unsafe impl DeviceRepr for PublicationBank {}
unsafe impl DeviceRepr for PublicationRoleCount {}
unsafe impl DeviceRepr for PublicationContract {}
unsafe impl DeviceRepr for PendingContinuation {}
unsafe impl DeviceRepr for ModelUpdateBinding {}
unsafe impl DeviceRepr for ModelUpdateEvidenceSource {}
unsafe impl DeviceRepr for ModelForwardSealInput {}
unsafe impl DeviceRepr for ModelForwardReceipt {}
unsafe impl DeviceRepr for PublicationCommand {}
unsafe impl DeviceRepr for PublicationDeliveryInput {}
unsafe impl DeviceRepr for AcknowledgementQueueHeader {}
unsafe impl DeviceRepr for AcknowledgementEntry {}
unsafe impl DeviceRepr for PublicationLease {}
unsafe impl DeviceRepr for SemanticTensorLayout {}
// SAFETY: padding-free C records containing initialized u64 values only.
unsafe impl DeviceRepr for TensorLayoutTableHeader {}
unsafe impl DeviceRepr for SemanticActiveRow {}
unsafe impl DeviceRepr for CompletionCoverage {}
unsafe impl DeviceRepr for RawFeedbackRecord {}
unsafe impl DeviceRepr for AttemptReceipt {}
unsafe impl DeviceRepr for IntentQueueHeader {}
unsafe impl DeviceRepr for IntentEntry {}
unsafe impl DeviceRepr for TokenProvenance {}

const _: () = assert!(size_of::<SourceSlot>() == 64);
const _: () = assert!(size_of::<PublicationStorageEntry>() == 24);
const _: () = assert!(size_of::<PublicationRange>() == 128);
const _: () = assert!(size_of::<PublicationHeader>() == 488);
const _: () = assert!(size_of::<PublicationControl>() == 144);
const _: () = assert!(size_of::<PublicationBank>() == 50360);
const _: () = assert!(size_of::<PublicationRoleCount>() == 16);
const _: () = assert!(size_of::<SemanticModelContractLayout>() == 48);
const _: () = assert!(size_of::<PublicationContract>() == 272);
const _: () = assert!(size_of::<SemanticTextRow>() == 16);
const _: () = assert!(size_of::<TextBinding>() == 24);
const _: () = assert!(size_of::<ModelUpdateBinding>() == 32);
const _: () = assert!(size_of::<ModelUpdateEvidenceSource>() == 48);
const _: () = assert!(size_of::<ModelForwardSealInput>() == 32);
const _: () = assert!(size_of::<ModelForwardReceipt>() == 232);
const _: () = assert!(size_of::<ModelForwardReceiptInputs>() == 128);
const _: () = assert!(size_of::<PublicationCommand>() == 24);
const _: () = assert!(size_of::<PublicationDeliveryInput>() == 88);
const _: () = assert!(size_of::<PublicationLease>() == 88);
const _: () = assert!(size_of::<SemanticTensorLayout>() == 112);
const _: () = assert!(size_of::<TensorLayoutTableHeader>() == 32);
const _: () = assert!(size_of::<SemanticActiveRow>() == 32);
const _: () = assert!(size_of::<CompletionCoverage>() == 360);
const _: () = assert!(size_of::<RawFeedbackRecord>() == 384);
const _: () = assert!(size_of::<AttemptReceipt>() == 352);
const _: () = assert!(size_of::<IntentQueueHeader>() == 88);
const _: () = assert!(size_of::<AcknowledgementQueueHeader>() == 72);
const _: () = assert!(size_of::<AcknowledgementEntry>() == 136);
const _: () = assert!(size_of::<IntentEntry>() == 344);
const _: () = assert!(size_of::<TokenProvenance>() == 184);

#[derive(Clone)]
enum PublicationPayload {
    Metadata(Vec<u8>),
    Tensor(PreparedSemanticTensor),
    Uncomputed,
}

struct PublicationAllocationPlan {
    role: u64,
    index: u64,
    capacity: usize,
    length: usize,
    logical_begin: u64,
    logical_end: u64,
    payload: PublicationPayload,
}

/// One reachable range of a cold publication material. Allocation capacity is
/// retained for future appends; bytes outside the sealed extent are not exported.
#[derive(Clone)]
struct PublicationMaterialRange {
    range: PublicationRange,
    capacity: usize,
    bytes: Vec<u8>,
}

/// Original non-tensor feedback material from a completed acquired step.
/// `identity` is its native range seal, not SHA-256 of `bytes` alone. Raw slots
/// (role 15), statement bytes (16) and provenance records (17) stay separate;
/// encoded feature tensors are not a replacement for any of these records.
pub struct SemanticFeedbackRecordMaterial {
    pub role: SemanticStateRole,
    pub index: u64,
    pub generation: u64,
    pub capacity_bytes: u64,
    pub logical_begin: u64,
    pub logical_end: u64,
    pub identity: Identity256,
    pub bytes: Vec<u8>,
}

/// Canonical native witnesses retained by one actually completed step.
/// The identity names the retained native owner and is deliberately independent
/// of the canonical bytes hash recorded by downstream closure storage.
#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
pub struct SemanticCompletedStepWitnessMaterial {
    pub identity: Identity256,
    pub bytes: Vec<u8>,
}

#[cfg(feature = "semantic-policy")]
pub struct SemanticCompletedModelCarrierMaterial {
    pub numerical_realization: SemanticCompletedStepWitnessMaterial,
    pub logits: SemanticCompletedStepWitnessMaterial,
    pub random_state: SemanticCompletedStepWitnessMaterial,
}

/// One exact categorical decision and the native closure materials needed to
/// replay its probability law and selected-score VJP without parsing a private
/// device ABI.
#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
pub struct SemanticCompletedActionComponentMaterial {
    pub ordinal: u32,
    pub null: bool,
    pub choice: u32,
    pub legal_count: u32,
    pub active_count: u32,
    pub probability_numerator: [u64; 3],
    pub probability_denominator: [u64; 3],
    pub importance_denominator: [u64; 3],
    pub cumulative_mass_below: [u64; 3],
    pub cdf_start: u64,
    pub cdf_end: u64,
    pub mass: u64,
    pub selected_rank: u32,
    pub draw: u64,
    pub key: [u32; 2],
    pub counter: [u32; 4],
    pub final_mask: SemanticCompletedStepWitnessMaterial,
    pub pwl_cell: SemanticCompletedStepWitnessMaterial,
    pub active_set: SemanticCompletedStepWitnessMaterial,
    pub vjp: SemanticCompletedStepWitnessMaterial,
    pub component_receipt: SemanticCompletedStepWitnessMaterial,
    pub hard_decode_receipt: Option<SemanticCompletedStepWitnessMaterial>,
}

/// Exact decoded choices and native admission receipts for one learned lane.
#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
pub struct SemanticCompletedActionLaneMaterial {
    /// Exact non-NULL learned text actions as (original source slot, token).
    pub text_actions: Vec<(u32, u32)>,
    pub edit_actions: [[u32; 18]; 2],
    pub admitted: bool,
    pub refusal_reason: Option<&'static str>,
    pub admission: SemanticCompletedStepWitnessMaterial,
    pub hard_decode_receipts: [SemanticCompletedStepWitnessMaterial; 2],
}

/// One actual native structural insertion attempt, including a duplicate
/// attachment. The lane verdict is independent of winner selection.
#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
pub struct SemanticCompletedTheoryDeltaMaterial {
    pub kind: &'static str,
    pub delta: SemanticCompletedStepWitnessMaterial,
    pub theory_generation: Identity256,
    pub verdict: &'static str,
    pub evidence: SemanticCompletedStepWitnessMaterial,
    pub lane: u32,
    pub slot: u32,
}

/// Terminal native result for one learned lane of a completed task ground.
/// A refusal never invents query results for a request that was not executed.
#[cfg(feature = "semantic-policy")]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SemanticCompletedLaneOutcomeMaterial {
    Executed([crate::SemanticTruth; 3]),
    Refused(SemanticTaskRefusal),
}

/// Typed semantic ground retained by the same completed Proposal owner as the
/// action projection. Learned attempted requests remain in `lanes`; this value
/// records their terminal execution results without creating a replay path.
#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
pub struct SemanticCompletedTaskGroundMaterial {
    pub witness: SemanticCompletedStepWitnessMaterial,
    /// Original six admitted coefficients and their finite signed return bound.
    pub scoring_law: SemanticCompletedStepWitnessMaterial,
    pub scoring: SemanticTaskScoring,
    pub return_bound: i64,
    pub structural_cost: SemanticStructuralCostDescriptor,
    pub task_identity: Identity256,
    pub content: SemanticTaskContentIdentity,
    pub goal: SemanticTaskGoalWitness,
    pub priority_levels: Vec<SemanticTaskPriorityLevel>,
    pub base: SemanticPublishedIdentity,
    pub expected_truth: [crate::SemanticTruth; 3],
    pub facts: [SemanticTaskFacts; 3],
    pub base_truth: [crate::SemanticTruth; 3],
    pub lane_outcomes: [SemanticCompletedLaneOutcomeMaterial; 2],
}

/// A minimal learned lane that is genuinely decisive for the bound semantic
/// goal. Presence is the edit-supervision membership decision; selection does
/// not depend on the policy winner, return, or an admission-only flag.
#[cfg(feature = "semantic-policy")]
#[derive(Clone)]
pub struct SemanticCompletedEditSolutionMaterial {
    pub witness: SemanticCompletedStepWitnessMaterial,
    pub lane: u64,
    pub component_begin: u64,
    pub component_end: u64,
    pub structural_delta: SemanticTransitionWork,
    pub resulting_state_receipt: SemanticCompletedStepWitnessMaterial,
}

/// Cold typed projection of one completed Proposal action. All byte-backed
/// children retain the same owner identity and are observations, not authority.
#[cfg(feature = "semantic-policy")]
pub struct SemanticCompletedActionProjectionMaterial {
    pub owner: SemanticCompletedStepWitnessMaterial,
    /// Original cold parent prefill only; later and restored parents have no
    /// stage-owned input/output witness to export.
    pub initial_prefill: Option<SemanticCompletedStepWitnessMaterial>,
    /// This action's own late pre-action checkpoint reference, sealed against
    /// retained custody. Never present alongside an initial-prefill child.
    pub pre_action_checkpoint: Option<SemanticCompletedStepWitnessMaterial>,
    /// Exact cold-exported predecessor root when its native digest still matches
    /// this Proposal's acquired parent. Later changed roots are not invented.
    pub world_root: Option<SemanticCompletedStepWitnessMaterial>,
    pub schema_generation: SemanticCompletedStepWitnessMaterial,
    pub action_law: SemanticCompletedStepWitnessMaterial,
    pub edit_codebook: SemanticCompletedStepWitnessMaterial,
    pub roster: SemanticCompletedStepWitnessMaterial,
    /// Original pre-draw physical bounds and their native model/profile binding.
    /// Non-actor actions and models without a physical roster have no certificate.
    pub estimator_bound: Option<SemanticCompletedStepWitnessMaterial>,
    /// Native digest of the semantic root acquired by this Proposal.
    pub predecessor_semantic_root_digest: Identity256,
    pub predecessor: SemanticPublishedIdentity,
    pub successor: SemanticPublishedIdentity,
    pub proposal: u64,
    pub stream_serial: u64,
    pub family_id: u64,
    pub action_law_generation: u64,
    pub model_generation: u64,
    pub winner: u64,
    pub actor_eligible: bool,
    pub total_return_bits: u64,
    pub batch_root: Identity256,
    pub batch_receipt: SemanticCompletedStepWitnessMaterial,
    pub result: SemanticCompletedStepWitnessMaterial,
    pub action_rng_base: SemanticCompletedStepWitnessMaterial,
    pub action_rng_successor: SemanticCompletedStepWitnessMaterial,
    pub base_logical_state: SemanticCompletedStepWitnessMaterial,
    pub successor_logical_state: SemanticCompletedStepWitnessMaterial,
    pub slot_zero_admission: SemanticCompletedStepWitnessMaterial,
    pub lanes: [SemanticCompletedActionLaneMaterial; 2],
    pub theory_deltas: Vec<SemanticCompletedTheoryDeltaMaterial>,
    pub components: Vec<SemanticCompletedActionComponentMaterial>,
    pub task_ground: SemanticCompletedTaskGroundMaterial,
    pub edit_solution: Option<SemanticCompletedEditSolutionMaterial>,
    pub attempt_receipt: SemanticCompletedStepWitnessMaterial,
}

/// Cold capacity of every native material one original Proposal can export.
/// Counts deliberately precede digest deduplication and outcome selection.
#[cfg(feature = "semantic-policy")]
#[derive(Default)]
pub struct SemanticCompletedMaterialCapacity {
    pub material_count: usize,
    pub largest_material_bytes: usize,
    pub total_material_bytes: usize,
    /// Numerical realization, structural logits, and random state, in that order.
    pub carrier_bytes: [usize; 3],
    pub attempt_receipt_bytes: usize,
    pub publication_evidence_bytes: usize,
}

#[cfg(feature = "semantic-policy")]
fn completed_material_extent(parts: &[usize]) -> Result<usize, SemanticTransitionError> {
    parts.iter().try_fold(0usize, |total, &bytes| {
        total.checked_add(bytes).ok_or_else(|| {
            publication_input_error("completed material capacity exceeds host extent")
        })
    })
}

#[cfg(feature = "semantic-policy")]
fn repeated_material_extent(count: usize, bytes: usize) -> Result<usize, SemanticTransitionError> {
    count
        .checked_mul(bytes)
        .ok_or_else(|| publication_input_error("completed material capacity exceeds host extent"))
}

#[cfg(feature = "semantic-policy")]
impl SemanticCompletedMaterialCapacity {
    fn add(&mut self, bytes: usize) -> Result<(), SemanticTransitionError> {
        self.material_count = completed_material_extent(&[self.material_count, 1])?;
        self.total_material_bytes = completed_material_extent(&[self.total_material_bytes, bytes])?;
        self.largest_material_bytes = self.largest_material_bytes.max(bytes);
        Ok(())
    }

    fn child(&mut self, kind: &[u8], payload: usize) -> Result<usize, SemanticTransitionError> {
        let bytes = completed_material_extent(&[
            b"XLOG-COMPLETED-ACTION-CHILD\0".len(),
            32 + 4 * size_of::<u64>(),
            kind.len(),
            payload,
        ])?;
        self.add(bytes)?;
        Ok(bytes)
    }
}

impl PublicationMaterialRange {
    fn into_feedback_record(
        self,
    ) -> Result<SemanticFeedbackRecordMaterial, SemanticTransitionError> {
        if !matches!(self.range.role, 15..=17)
            || self.range.generation != 1
            || self.range.length_bytes != self.bytes.len() as u64
            || self.bytes.is_empty()
            || self.bytes.len() > self.capacity
            || self.range.logical_begin != 0
            || (self.range.role != 15 && self.range.logical_end != 0)
            || (self.range.role == 15
                && (!self
                    .bytes
                    .len()
                    .is_multiple_of(size_of::<RawFeedbackRecord>())
                    || self.range.logical_end
                        > (self.bytes.len() / size_of::<RawFeedbackRecord>()) as u64))
            || self.original_record_digest() != self.range.digest
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticFeedbackRecordMaterial {
            role: SemanticStateRole::from_code(self.range.role).expect("checked feedback role"),
            index: self.range.index,
            generation: self.range.generation,
            capacity_bytes: self.capacity as u64,
            logical_begin: self.range.logical_begin,
            logical_end: self.range.logical_end,
            identity: self.range.digest,
            bytes: self.bytes,
        })
    }

    // Exact opaque-record branch of publication_content_view. Runtime words
    // must remain present here, including those normalized out of Hlogical.
    fn original_record_digest(&self) -> Identity256 {
        debug_assert!(!is_tensor_role(self.range.role));
        self.record_digest(&self.bytes)
    }

    fn digest_prefix(&self) -> [u64; 16] {
        let mut prefix = [0u64; 16];
        prefix[..5].copy_from_slice(&[
            0x786c6f6772616e31,
            self.range.role,
            self.range.index,
            self.range.logical_begin,
            self.range.logical_end,
        ]);
        prefix
    }

    fn record_digest(&self, bytes: &[u8]) -> Identity256 {
        let mut hash = Sha256::new();
        for word in self.digest_prefix() {
            hash.update(word.to_le_bytes());
        }
        hash.update(bytes);
        Identity256::from_bytes(hash.finalize().into())
    }

    /// Cold form of publication_content_view for the original cache roster.
    /// This traverses the same logical coordinates as CUDA, not storage padding.
    fn cache_projection(
        &self,
        layout: SemanticTensorLayout,
    ) -> Result<SemanticPublicationTensorProjection, SemanticTransitionError> {
        tensor_layout_bytes(&layout)?;
        if !matches!(layout.role, 4..=13)
            || (layout.role, layout.index) != (self.range.role, self.range.index)
            || layout.strides_bytes[..layout.rank as usize]
                .iter()
                .any(|stride| !stride.is_multiple_of(layout.element_bytes))
        {
            return Err(publication_input_error(
                "cache material has another tensor layout",
            ));
        }
        let mut dimensions = layout.dimensions;
        if layout.logical_axis != u64::MAX {
            let axis = layout.logical_axis as usize;
            dimensions[axis] = self.range.logical_end - self.range.logical_begin;
            if dimensions[axis] > layout.dimensions[axis] {
                return Err(publication_input_error(
                    "cache interval exceeds its original layout",
                ));
            }
        }
        let cells =
            dimensions[..layout.rank as usize]
                .iter()
                .try_fold(1u64, |cells, &dimension| {
                    cells
                        .checked_mul(dimension)
                        .ok_or(SemanticTransitionError::GenerationExhausted)
                })?;
        let length = cells
            .checked_mul(layout.element_bytes)
            .and_then(|bytes| usize::try_from(bytes).ok())
            .filter(|&bytes| bytes <= self.bytes.len())
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let mut logical_bytes = Vec::with_capacity(length);
        for cell in 0..cells {
            let mut coordinate = cell;
            let mut offset = 0u64;
            for axis in (0..layout.rank as usize).rev() {
                let at = coordinate % dimensions[axis];
                coordinate /= dimensions[axis];
                offset = at
                    .checked_mul(layout.strides_bytes[axis])
                    .and_then(|bytes| offset.checked_add(bytes))
                    .ok_or(SemanticTransitionError::GenerationExhausted)?;
            }
            let start = usize::try_from(offset)
                .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
            let end = offset
                .checked_add(layout.element_bytes)
                .and_then(|bytes| usize::try_from(bytes).ok())
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            logical_bytes.extend_from_slice(
                self.bytes
                    .get(start..end)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?,
            );
        }
        let mut prefix = self.digest_prefix();
        prefix[5..9].copy_from_slice(&[
            layout.element_bytes,
            layout.scalar_type,
            layout.rank,
            layout.logical_axis,
        ]);
        prefix[9..13].copy_from_slice(&dimensions);
        let mut hash = Sha256::new();
        for word in prefix {
            hash.update(word.to_le_bytes());
        }
        hash.update(&logical_bytes);
        if Identity256::from_bytes(hash.finalize().into()) != self.range.digest {
            return Err(publication_input_error(
                "cache bytes differ from their original native seal",
            ));
        }
        Ok(SemanticPublicationTensorProjection {
            layout,
            capacity_bytes: self.capacity as u64,
            logical_begin: self.range.logical_begin,
            logical_end: self.range.logical_end,
            identity: self.range.digest,
            logical_bytes,
        })
    }

    fn attempt(&self) -> Result<AttemptReceipt, SemanticTransitionError> {
        if self.range.role != 33 || self.bytes.len() != size_of::<AttemptReceipt>() {
            return Err(publication_input_error(
                "replay evidence requires the whole native attempt receipt",
            ));
        }
        // SAFETY: the checked, padding-free ABI contains only integer/digest fields.
        Ok(unsafe { std::ptr::read_unaligned(self.bytes.as_ptr().cast::<AttemptReceipt>()) })
    }

    // Exact PublicationLogicalBytes normalization for the publication-only
    // records and completion coverage. This is a cold comparison, never a
    // substitute for the actual device publication seals.
    fn logical_record_digest(&self) -> Result<Identity256, SemanticTransitionError> {
        let mut bytes = self.bytes.clone();
        match self.range.role {
            14 | 33 => {
                let (extent, first, last, tail) = if self.range.role == 14 {
                    (size_of::<CompletionCoverage>(), 1, 5, 41)
                } else {
                    (size_of::<AttemptReceipt>(), 1, 6, 39)
                };
                if bytes.len() != extent {
                    return Err(publication_input_error(
                        "replay record has another native ABI extent",
                    ));
                }
                bytes[first * 8..(last + 1) * 8].fill(0);
                bytes[tail * 8..].fill(0);
            }
            30 => {
                if bytes.len() < size_of::<IntentQueueHeader>() {
                    return Err(publication_input_error(
                        "replay intent queue omits its native header",
                    ));
                }
                // SAFETY: the checked prefix is an all-integer, padding-free ABI.
                let header =
                    unsafe { std::ptr::read_unaligned(bytes.as_ptr().cast::<IntentQueueHeader>()) };
                if header.abi != 1
                    || header.count > header.capacity
                    || header
                        .count
                        .checked_mul(size_of::<IntentEntry>() as u64)
                        .and_then(|n| n.checked_add(size_of::<IntentQueueHeader>() as u64))
                        != Some(bytes.len() as u64)
                {
                    return Err(publication_input_error(
                        "replay intent queue differs from its exact native extent",
                    ));
                }
                for entry in bytes[size_of::<IntentQueueHeader>()..]
                    .as_chunks_mut::<{ size_of::<IntentEntry>() }>()
                    .0
                {
                    entry[30 * 8..35 * 8].fill(0);
                }
            }
            27 | 28 | 31 | 32 => {}
            _ => {
                return Err(publication_input_error(
                    "record is not a native replay comparison record",
                ))
            }
        }
        Ok(self.record_digest(&bytes))
    }

    fn encode_into(&self, bytes: &mut Vec<u8>) -> Result<(), SemanticTransitionError> {
        material_bytes(bytes, &publication_abi_bytes(&[self.range]))
            .map_err(SemanticTransitionError::Semantic)?;
        material_u64(bytes, self.capacity as u64);
        material_bytes(bytes, &self.bytes).map_err(SemanticTransitionError::Semantic)
    }

    fn decode_from(
        reader: &mut SemanticMaterialReader<'_>,
    ) -> Result<Self, SemanticTransitionError> {
        // SAFETY: the range ABI contains only integer/digest fields.
        let range = unsafe { publication_material_record::<PublicationRange>(reader)? };
        let capacity = usize::try_from(reader.u64().map_err(SemanticTransitionError::Semantic)?)
            .map_err(|_| {
                publication_input_error("publication material capacity exceeds host extent")
            })?;
        let bytes = reader
            .bytes()
            .map_err(SemanticTransitionError::Semantic)?
            .to_vec();
        Ok(Self {
            range,
            capacity,
            bytes,
        })
    }
}

// publication_fold hashes digest bytes followed by two little-endian ABI words
// and the content digest. Identity256 preserves the CUDA SHA output byte order.
fn publication_fold_digest(
    digest: Identity256,
    role: u64,
    index: u64,
    content: Identity256,
) -> Identity256 {
    let mut hash = Sha256::new();
    hash.update(digest.as_bytes());
    hash.update(role.to_le_bytes());
    hash.update(index.to_le_bytes());
    hash.update(content.as_bytes());
    Identity256::from_bytes(hash.finalize().into())
}

fn publication_action_receipts_digest(
    codebook: &PublicationMaterialRange,
    receipts: &[SemanticTransitionReceipt],
) -> Result<Identity256, SemanticTransitionError> {
    // publication_logical_codebook_digest and PublicationActionReceiptBytes:
    // owner/slot/generation and the runtime admission binding are audit data.
    if codebook.range.role != 48 {
        return Err(publication_input_error(
            "replay action codebook has another native extent",
        ));
    }
    publication_action_receipts_digest_bytes(&codebook.bytes, receipts)
}

fn publication_action_receipts_digest_bytes(
    bytes: &[u8],
    receipts: &[SemanticTransitionReceipt],
) -> Result<Identity256, SemanticTransitionError> {
    if bytes.len() < 25 * 8 || !bytes.len().is_multiple_of(8) {
        return Err(publication_input_error(
            "replay action codebook has another native extent",
        ));
    }
    let word =
        |index: usize| u64::from_le_bytes(bytes[index * 8..(index + 1) * 8].try_into().unwrap());
    let (offset, length) = (word(8), word(9));
    if offset % 8 != 0
        || offset > bytes.len() as u64
        || length > bytes.len() as u64 - offset
        || (offset + length).div_ceil(8) != (bytes.len() / 8) as u64
    {
        return Err(publication_input_error(
            "replay action codebook omits its exact statement payload",
        ));
    }
    let mut hash = Sha256::new();
    hash.update(b"xlog.semantic.logical-codebooks.v1\0");
    hash.update(CATALOGUE_DIGEST);
    hash.update(((bytes.len() / 8) as u64).to_le_bytes());
    for (index, bytes) in bytes.as_chunks::<8>().0.iter().enumerate() {
        hash.update(if matches!(index, 14..=16 | 21..=24) {
            &[0; 8]
        } else {
            bytes
        });
    }
    let binding = Identity256::from_bytes(hash.finalize().into());
    let mut hash = Sha256::new();
    for receipt in receipts {
        let mut normalized = *receipt;
        if normalized.catalogue_generation == CATALOGUE_GENERATION {
            normalized.admission_binding = binding;
        }
        hash.update(publication_abi_bytes(&[normalized]));
    }
    Ok(Identity256::from_bytes(hash.finalize().into()))
}

fn publication_semantic_receipts_digest(receipts: &[[u64; 42]; 7]) -> Identity256 {
    let mut hash = Sha256::new();
    for receipt in receipts {
        for (index, &word) in receipt.iter().enumerate() {
            hash.update(
                if matches!(index, 3..=12 | 34..=41) {
                    0
                } else {
                    word
                }
                .to_le_bytes(),
            );
        }
    }
    Identity256::from_bytes(hash.finalize().into())
}

fn publication_action_batch_root(batch: &SemanticActionBatchReceipt) -> Identity256 {
    Identity256::from_bytes(Sha256::digest(publication_abi_bytes(&[*batch])).into())
}

const REPLAY_EVIDENCE_ROLES: [u64; 6] = [27, 28, 30, 31, 32, 33];
const REPLAY_EVIDENCE_MAGIC: &[u8] = b"XLOG-REPLAY-EVIDENCE\0";
const REPLAY_PROVENANCE_MAGIC: &[u8] = b"XLOG-REPLAY-PROVENANCE\0";

fn encode_publication_identity(bytes: &mut Vec<u8>, identity: SemanticPublishedIdentity) {
    bytes.extend_from_slice(identity.instance.as_bytes());
    material_u64(bytes, identity.word);
    bytes.extend_from_slice(identity.logical_digest.as_bytes());
    bytes.extend_from_slice(identity.state_digest.as_bytes());
}

#[cfg(feature = "semantic-policy")]
fn completed_action_child_material(
    owner: Identity256,
    kind: &[u8],
    ordinal: u64,
    payload: &[u8],
) -> SemanticCompletedStepWitnessMaterial {
    let mut owner_binding = Vec::new();
    owner_binding.extend_from_slice(b"xlog.completed-action-child.v1\0");
    owner_binding.extend_from_slice(owner.as_bytes());
    material_u64(&mut owner_binding, kind.len() as u64);
    owner_binding.extend_from_slice(kind);
    material_u64(&mut owner_binding, ordinal);
    let identity = Identity256::from_bytes(Sha256::digest(&owner_binding).into());

    let mut bytes = Vec::new();
    bytes.extend_from_slice(b"XLOG-COMPLETED-ACTION-CHILD\0");
    material_u64(&mut bytes, 1);
    bytes.extend_from_slice(owner.as_bytes());
    material_u64(&mut bytes, kind.len() as u64);
    bytes.extend_from_slice(kind);
    material_u64(&mut bytes, ordinal);
    material_u64(&mut bytes, payload.len() as u64);
    bytes.extend_from_slice(payload);
    SemanticCompletedStepWitnessMaterial { identity, bytes }
}

#[cfg(feature = "semantic-policy")]
fn encode_completed_component_receipt(bytes: &mut Vec<u8>, receipt: SemanticTransitionReceipt) {
    material_u64(bytes, receipt.proposal);
    material_u64(bytes, receipt.catalogue_generation);
    bytes.extend_from_slice(receipt.catalogue_digest.as_bytes());
    bytes.extend_from_slice(receipt.admission_binding.as_bytes());
    for value in [
        receipt.ordinal,
        receipt.lane,
        receipt.slot,
        receipt.field,
        receipt.kind,
        receipt.choice,
        receipt.legal_count,
        receipt.active_count,
        receipt.selected_rank,
    ] {
        material_u64(bytes, value as u64);
    }
    for value in receipt.key {
        material_u64(bytes, value as u64);
    }
    for value in receipt.counter {
        material_u64(bytes, value as u64);
    }
    for value in receipt.random_words {
        material_u64(bytes, value as u64);
    }
    for value in [
        receipt.draw,
        receipt.cdf_start,
        receipt.cdf_end,
        receipt.mass,
    ] {
        material_u64(bytes, value);
    }
    for limbs in [
        receipt.p,
        receipt.q,
        receipt.factor_denominator,
        receipt.cumulative_mass_below,
    ] {
        for value in limbs {
            material_u64(bytes, value);
        }
    }
    material_u64(bytes, receipt.active_fields as u64);
    material_u64(bytes, receipt.null_fields as u64);
}

#[cfg(feature = "semantic-policy")]
fn completed_receipt_material(
    owner: Identity256,
    kind: &[u8],
    ordinal: u64,
    receipt: &[u64; 42],
) -> SemanticCompletedStepWitnessMaterial {
    let mut payload = Vec::new();
    for value in receipt {
        material_u64(&mut payload, *value);
    }
    completed_action_child_material(owner, kind, ordinal, &payload)
}

#[expect(
    clippy::too_many_arguments,
    reason = "the native rule receipt binds task, lane, slot, current edit, and prior edit independently"
)]
fn validated_rule_receipt(
    codebooks: &ActionCodebooks,
    program: &crate::SemanticProgramAdmission,
    task_identity: Identity256,
    lane: usize,
    slot: usize,
    choices: &[u32; 18],
    previous_choices: Option<&[u32; 18]>,
    receipt: &[u64; 42],
) -> Result<
    (
        SemanticDecodedRuleInsertion,
        Option<crate::SemanticProgramRule>,
    ),
    SemanticTransitionError,
> {
    let mismatch = || SemanticTransitionError::ObservationMismatch;
    if lane >= 2 || slot >= 2 {
        return Err(mismatch());
    }
    let decoded = codebooks.decoded_rule_insertion(program, choices)?;
    let previous = match previous_choices {
        Some(prior) if prior[0] == 1 && prior[1] == 2 => {
            Some(codebooks.decoded_rule_insertion(program, prior)?.rule)
        }
        Some(prior) if prior.iter().all(|&choice| choice == 0) => None,
        None => None,
        _ => return Err(mismatch()),
    };
    let previous_fields = previous.map(semantic_program_rule_words).unwrap_or([0; 10]);
    if receipt[0] != 0
        || receipt[1] != 3
        || receipt[2] != lane as u64 + 1
        || receipt[3] != slot as u64
        || receipt[4..8] != identity_words(*task_identity.as_bytes())
        || receipt[8..12] != identity_words(*codebooks.binding.digest.as_bytes())
        || receipt[12..22] != semantic_program_rule_words(decoded.rule)
        || receipt[22] != program.initial_facts.len() as u64
        || receipt[23] != program.initial_rules.len() as u64
        || receipt[24] != u64::from(previous.is_some())
        || receipt[25..35] != previous_fields
        || receipt[35..].iter().any(|&word| word != 0)
    {
        return Err(mismatch());
    }
    Ok((decoded, previous))
}

#[cfg(feature = "semantic-policy")]
#[expect(
    clippy::too_many_arguments,
    reason = "one delta binds independent native owner, source, decode, and admission receipts"
)]
fn completed_theory_delta_for_slot(
    codebooks: &ActionCodebooks,
    admission: &SemanticAdmission,
    program: Option<&crate::SemanticProgramAdmission>,
    task_identity: Identity256,
    owner: Identity256,
    predecessor_semantic_root_digest: Identity256,
    lane: usize,
    slot: usize,
    choices: &[u32; 18],
    previous_choices: Option<&[u32; 18]>,
    hard_decode: &[u64; 42],
    lane_admission: &[u64; 42],
    component_receipts: &[SemanticTransitionReceipt],
    lane_refusal: u64,
) -> Result<Option<SemanticCompletedTheoryDeltaMaterial>, SemanticTransitionError> {
    if lane >= 2
        || slot >= 2
        || component_receipts.len() != 18
        || hard_decode[0] != 0
        || hard_decode[1] > 3
        || lane_refusal > 4
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    if hard_decode[1] == 0 {
        if choices[0] == 1 && choices[1] == 2 {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        return Ok(None);
    }
    if hard_decode[1] == 3 {
        let program = program.ok_or(SemanticTransitionError::ObservationMismatch)?;
        let (decoded, previous) = validated_rule_receipt(
            codebooks,
            program,
            task_identity,
            lane,
            slot,
            choices,
            previous_choices,
            hard_decode,
        )?;
        let previous_fields = previous.map(semantic_program_rule_words).unwrap_or([0; 10]);
        let program_binding = ActionCodebooks::program_binding(program);
        let theory_generation = if previous.is_some() {
            let mut hash = Sha256::new();
            hash.update(b"xlog.semantic.program-theory.v1\0");
            hash.update(program_binding.as_bytes());
            for word in previous_fields {
                hash.update(word.to_le_bytes());
            }
            Identity256::from_bytes(hash.finalize().into())
        } else {
            program_binding
        };
        let ordinal = (lane * 2 + slot) as u64;
        let delta =
            completed_action_child_material(owner, b"theory-rule-delta", ordinal, &decoded.bytes);
        let mut payload = Vec::new();
        payload.extend_from_slice(theory_generation.as_bytes());
        payload.extend_from_slice(task_identity.as_bytes());
        material_u64(&mut payload, lane as u64 + 1);
        material_u64(&mut payload, slot as u64);
        material_u64(&mut payload, lane_refusal);
        for receipt in [hard_decode, lane_admission] {
            for &word in receipt {
                material_u64(&mut payload, word);
            }
        }
        for receipt in component_receipts {
            encode_completed_component_receipt(&mut payload, *receipt);
        }
        let evidence = completed_action_child_material(
            owner,
            b"theory-rule-delta-evidence",
            ordinal,
            &payload,
        );
        return Ok(Some(SemanticCompletedTheoryDeltaMaterial {
            kind: "rule",
            delta,
            theory_generation,
            verdict: if lane_refusal == 0 {
                "accepted"
            } else {
                "rejected"
            },
            evidence,
            lane: lane as u32 + 1,
            slot: slot as u32,
        }));
    }
    if program.is_some() {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let decoded = codebooks
        .decoded_support_insertion(admission, choices)?
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    if hard_decode[20..24] != identity_words(*decoded.statement.as_bytes())
        || hard_decode[24..28] != identity_words(*decoded.support.as_bytes())
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let ordinal = (lane * 2 + slot) as u64;
    let delta = completed_action_child_material(owner, b"theory-delta", ordinal, &decoded.bytes);
    let mut payload = Vec::new();
    payload.extend_from_slice(predecessor_semantic_root_digest.as_bytes());
    material_u64(&mut payload, lane as u64 + 1);
    material_u64(&mut payload, slot as u64);
    material_u64(&mut payload, lane_refusal);
    material_u32(&mut payload, decoded.source_event);
    for reference in decoded.reconstruction {
        material_u32(&mut payload, reference);
    }
    for receipt in [hard_decode, lane_admission] {
        for &word in receipt {
            material_u64(&mut payload, word);
        }
    }
    for receipt in component_receipts {
        encode_completed_component_receipt(&mut payload, *receipt);
    }
    let evidence =
        completed_action_child_material(owner, b"theory-delta-evidence", ordinal, &payload);
    Ok(Some(SemanticCompletedTheoryDeltaMaterial {
        kind: "fact",
        delta,
        theory_generation: predecessor_semantic_root_digest,
        verdict: if lane_refusal == 0 {
            "accepted"
        } else {
            "rejected"
        },
        evidence,
        lane: lane as u32 + 1,
        slot: slot as u32,
    }))
}

fn validate_program_query_receipts(
    program: &crate::SemanticProgramAdmission,
    task_identity: Identity256,
    codebooks: &ActionCodebooks,
    state: &DeviceState,
    edits: &[[[u32; 18]; 2]; 2],
) -> Result<(), SemanticTransitionError> {
    let mismatch = || SemanticTransitionError::ObservationMismatch;
    let expected_queries = 3 + state
        .task_evaluation
        .lane_refusal
        .iter()
        .filter(|&&refusal| refusal != 3 && refusal != 4)
        .count() as u64
        * 3;
    if state.binding_digest != codebooks.binding.digest
        || state.task_evaluation.query_count != expected_queries
        || state.task_evaluation.lane_refusal.contains(&1)
    {
        return Err(mismatch());
    }
    let mut inserted: [Vec<crate::SemanticProgramRule>; 2] = std::array::from_fn(|_| Vec::new());
    for (lane, actions) in edits.iter().enumerate() {
        for choices in actions {
            match (choices[0], choices[1]) {
                (0, 0) if choices[2..].iter().all(|&value| value == 0) => {}
                (1, 2) => {
                    inserted[lane].push(codebooks.decoded_rule_insertion(program, choices)?.rule)
                }
                _ => return Err(mismatch()),
            }
        }
    }
    let task_words = identity_words(*task_identity.as_bytes());
    let binding_words = identity_words(*codebooks.binding.digest.as_bytes());
    for slot in 0..3 {
        let rules: &[crate::SemanticProgramRule] =
            if slot == 0 { &[] } else { &inserted[slot - 1] };
        let receipts = &state.task_evaluation.query_receipts[slot];
        let facts = &state.task_evaluation.facts[slot];
        if slot != 0 && matches!(state.task_evaluation.lane_refusal[slot - 1], 3 | 4) {
            let work = state.work[slot - 1];
            if rules.is_empty()
                || receipts
                    .iter()
                    .any(|receipt| receipt.iter().any(|&word| word != 0))
                || facts.truth != [0; 3]
                || facts.correct != [0; 3]
                || facts.g != 0
                || facts.p != 0
                || facts.eligible != 0
                || work.edit_commands != rules.len() as u64
                || work.added_supports != 0
                || work.defined_truth_changes != 0
            {
                return Err(mismatch());
            }
            continue;
        }
        let metrics = &receipts[0][37..40];
        if metrics[1] > crate::semantic_program::RESIDENT_PROGRAM_FACT_CAPACITY as u64
            || metrics[2] > metrics[1]
            || facts.truth.iter().any(|&truth| truth > 1)
        {
            return Err(mismatch());
        }
        for (query, receipt) in receipts.iter().enumerate() {
            let mut expected = [0u64; 42];
            expected[1] = 0x5850524f47515545;
            expected[2] = facts.truth[query];
            expected[3] = slot as u64;
            expected[4] = query as u64;
            expected[5..9].copy_from_slice(&task_words);
            expected[9..13].copy_from_slice(&binding_words);
            expected[13] = rules.len() as u64;
            for (edit, rule) in rules.iter().enumerate() {
                expected[14 + edit * 10..24 + edit * 10]
                    .copy_from_slice(&semantic_program_rule_words(*rule));
            }
            let query_fact = program.queries[query];
            expected[34..37].copy_from_slice(&[
                u64::from(query_fact.predicate),
                u64::from(query_fact.first),
                u64::from(query_fact.second),
            ]);
            expected[37..40].copy_from_slice(metrics);
            expected[40] = program.initial_rules.len() as u64;
            expected[41] = program.initial_facts.len() as u64;
            if receipt != &expected {
                return Err(mismatch());
            }
        }
        if slot != 0 {
            let baseline = &state.task_evaluation.facts[0];
            let derived = metrics[2]
                .checked_sub(state.task_evaluation.query_receipts[0][0][39])
                .ok_or_else(mismatch)?;
            let truth_changes = facts
                .truth
                .iter()
                .zip(baseline.truth)
                .filter(|(current, original)| **current != *original)
                .count() as u64;
            let work = state.work[slot - 1];
            if work.edit_commands != rules.len() as u64
                || work.added_supports != derived
                || work.defined_truth_changes != truth_changes
            {
                return Err(mismatch());
            }
        }
    }
    Ok(())
}

#[cfg(feature = "semantic-policy")]
fn completed_task_truths(
    facts: SemanticTaskFacts,
) -> Result<[crate::SemanticTruth; 3], SemanticTransitionError> {
    Ok([
        crate::SemanticTruth::from_bits(facts.truth[0])
            .map_err(SemanticTransitionError::Semantic)?,
        crate::SemanticTruth::from_bits(facts.truth[1])
            .map_err(SemanticTransitionError::Semantic)?,
        crate::SemanticTruth::from_bits(facts.truth[2])
            .map_err(SemanticTransitionError::Semantic)?,
    ])
}

#[cfg(feature = "semantic-policy")]
fn encode_completed_task_facts(bytes: &mut Vec<u8>, facts: SemanticTaskFacts) {
    for value in facts.truth {
        material_u64(bytes, value);
    }
    for value in facts.correct {
        material_u64(bytes, value);
    }
    for value in [facts.g, facts.p, facts.c, facts.v as u64, facts.eligible] {
        material_u64(bytes, value);
    }
}

#[cfg(feature = "semantic-policy")]
fn bind_completed_material(bytes: &mut Vec<u8>, material: &SemanticCompletedStepWitnessMaterial) {
    bytes.extend_from_slice(material.identity.as_bytes());
    bytes.extend_from_slice(&Sha256::digest(&material.bytes));
}

#[cfg(feature = "semantic-policy")]
fn completed_logical_state_material(
    owner: Identity256,
    ordinal: u64,
    identity: SemanticPublishedIdentity,
) -> SemanticCompletedStepWitnessMaterial {
    let mut payload = Vec::new();
    encode_publication_identity(&mut payload, identity);
    let mut material = completed_action_child_material(owner, b"logical-state", ordinal, &payload);
    material.identity = identity.logical_digest;
    material
}

#[cfg(feature = "semantic-policy")]
fn completed_rng_material(
    owner: Identity256,
    ordinal: u64,
    model_generation: u64,
    stream_serial: u64,
    family_id: u64,
    proposal: u64,
) -> SemanticCompletedStepWitnessMaterial {
    let mut payload = Vec::new();
    for value in [model_generation, stream_serial, family_id, proposal] {
        material_u64(&mut payload, value);
    }
    completed_action_child_material(owner, b"action-rng", ordinal, &payload)
}

fn decode_publication_identity(
    reader: &mut SemanticMaterialReader<'_>,
) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
    let instance = Identity256::from_bytes(
        reader
            .take(32)
            .map_err(SemanticTransitionError::Semantic)?
            .try_into()
            .unwrap(),
    );
    let word = reader.u64().map_err(SemanticTransitionError::Semantic)?;
    let logical_digest = Identity256::from_bytes(
        reader
            .take(32)
            .map_err(SemanticTransitionError::Semantic)?
            .try_into()
            .unwrap(),
    );
    let state_digest = Identity256::from_bytes(
        reader
            .take(32)
            .map_err(SemanticTransitionError::Semantic)?
            .try_into()
            .unwrap(),
    );
    Ok(SemanticPublishedIdentity {
        instance,
        word,
        logical_digest,
        state_digest,
    })
}

// The reconstruction provenance root contains original authority bytes and the
// original continuation decision, never a new grant or the successor snapshot.
struct PublicationReplayProvenance {
    predecessor: SemanticPublishedIdentity,
    authority: PublicationMaterialRange,
    decision: PublicationMaterialRange,
}

impl PublicationReplayProvenance {
    fn encode(&self) -> Result<Vec<u8>, SemanticTransitionError> {
        let mut bytes = REPLAY_PROVENANCE_MAGIC.to_vec();
        material_u32(&mut bytes, 1);
        bytes.extend_from_slice(&publication_material_runtime());
        encode_publication_identity(&mut bytes, self.predecessor);
        self.authority.encode_into(&mut bytes)?;
        self.decision.encode_into(&mut bytes)?;
        Ok(bytes)
    }

    fn decode(bytes: &[u8]) -> Result<Self, SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(bytes);
        if reader
            .take(REPLAY_PROVENANCE_MAGIC.len())
            .map_err(SemanticTransitionError::Semantic)?
            != REPLAY_PROVENANCE_MAGIC
            || reader.u32().map_err(SemanticTransitionError::Semantic)? != 1
            || reader.take(32).map_err(SemanticTransitionError::Semantic)?
                != publication_material_runtime()
        {
            return Err(publication_input_error(
                "replay provenance requires its exact pinned native runtime",
            ));
        }
        let predecessor = decode_publication_identity(&mut reader)?;
        let authority = PublicationMaterialRange::decode_from(&mut reader)?;
        let decision = PublicationMaterialRange::decode_from(&mut reader)?;
        reader.finish().map_err(SemanticTransitionError::Semantic)?;
        Ok(Self {
            predecessor,
            authority,
            decision,
        })
    }

    fn validate(&self, predecessor: &PublicationMaterial) -> Result<(), SemanticTransitionError> {
        let header = predecessor.bank.header;
        let original = SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        };
        if self.predecessor != original {
            return Err(publication_input_error(
                "replay provenance names another original native predecessor",
            ));
        }
        for (item, role) in [(&self.authority, 38), (&self.decision, 39)] {
            let saved = predecessor
                .ranges
                .iter()
                .find(|item| item.range.role == role && item.range.index == 0)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if (item.range.role, item.range.index) != (role, 0)
                || item.range.generation != 1
                || item.range.length_bytes != item.bytes.len() as u64
                || item.capacity != saved.capacity
                || item.capacity == 0
                || item.bytes.is_empty()
                || item.bytes.len() > item.capacity
                || item.range.logical_begin > item.range.logical_end
                || item.original_record_digest() != item.range.digest
            {
                return Err(publication_input_error(
                    "replay provenance changes an originally sealed authority record",
                ));
            }
            if role == 38
                && (item.bytes != saved.bytes
                    || publication_abi_bytes(&[item.range])
                        != publication_abi_bytes(&[saved.range]))
            {
                return Err(publication_input_error("replay provenance differs from the predecessor's whole original authority envelope"));
            }
        }
        Ok(())
    }
}

struct PublicationReplayEvidence {
    successor: SemanticPublishedIdentity,
    ranges: Vec<PublicationMaterialRange>,
}

impl PublicationReplayEvidence {
    fn range(&self, role: u64) -> Result<&PublicationMaterialRange, SemanticTransitionError> {
        self.ranges
            .iter()
            .find(|item| item.range.role == role && item.range.index == 0)
            .ok_or_else(|| publication_input_error("replay evidence omits a publication record"))
    }

    fn state_digest(&self) -> Result<Identity256, SemanticTransitionError> {
        let mut digest = self.successor.logical_digest;
        for item in &self.ranges {
            digest = publication_fold_digest(
                digest,
                item.range.role,
                item.range.index,
                item.logical_record_digest()?,
            );
        }
        Ok(digest)
    }

    fn encode(&self) -> Result<Vec<u8>, SemanticTransitionError> {
        let mut bytes = REPLAY_EVIDENCE_MAGIC.to_vec();
        material_u32(&mut bytes, 1);
        bytes.extend_from_slice(&publication_material_runtime());
        encode_publication_identity(&mut bytes, self.successor);
        material_u32(
            &mut bytes,
            u32::try_from(self.ranges.len())
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
        );
        for item in &self.ranges {
            item.encode_into(&mut bytes)?;
        }
        Ok(bytes)
    }

    fn decode(bytes: &[u8]) -> Result<Self, SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(bytes);
        if reader
            .take(REPLAY_EVIDENCE_MAGIC.len())
            .map_err(SemanticTransitionError::Semantic)?
            != REPLAY_EVIDENCE_MAGIC
            || reader.u32().map_err(SemanticTransitionError::Semantic)? != 1
            || reader.take(32).map_err(SemanticTransitionError::Semantic)?
                != publication_material_runtime()
        {
            return Err(publication_input_error(
                "replay evidence requires its exact pinned native runtime",
            ));
        }
        let successor = decode_publication_identity(&mut reader)?;
        if reader.u32().map_err(SemanticTransitionError::Semantic)?
            != REPLAY_EVIDENCE_ROLES.len() as u32
        {
            return Err(publication_input_error(
                "replay evidence requires all six native publication records",
            ));
        }
        let mut ranges = Vec::with_capacity(REPLAY_EVIDENCE_ROLES.len());
        for _ in REPLAY_EVIDENCE_ROLES {
            ranges.push(PublicationMaterialRange::decode_from(&mut reader)?);
        }
        reader.finish().map_err(SemanticTransitionError::Semantic)?;
        Ok(Self { successor, ranges })
    }

    fn validate(
        &self,
        predecessor: &PublicationMaterial,
    ) -> Result<SemanticTransitionKind, SemanticTransitionError> {
        let base = predecessor.bank.header;
        let successor_word = (base.publication_word >> 1)
            .checked_add(1)
            .filter(|&epoch| epoch <= u64::MAX >> 1)
            .map(|epoch| (epoch << 1) | ((base.publication_word & 1) ^ 1))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        if self.successor.instance != base.instance
            || self.successor.word != successor_word
            || self.ranges.len() != REPLAY_EVIDENCE_ROLES.len()
        {
            return Err(publication_input_error(
                "replay evidence is not the original predecessor's immediate successor",
            ));
        }
        for (item, role) in self.ranges.iter().zip(REPLAY_EVIDENCE_ROLES) {
            let previous = predecessor
                .ranges
                .iter()
                .find(|item| item.range.role == role && item.range.index == 0)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if (item.range.role, item.range.index) != (role, 0)
                || item.range.generation != 1
                || item.range.length_bytes != item.bytes.len() as u64
                || item.capacity != previous.capacity
                || item.capacity == 0
                || item.bytes.len() > item.capacity
                || item.range.logical_begin > item.range.logical_end
                || item.original_record_digest() != item.range.digest
            {
                return Err(publication_input_error(
                    "replay evidence changes or omits an originally sealed publication record",
                ));
            }
        }
        let attempt_range = self.range(33)?;
        let attempt = attempt_range.attempt()?;
        let previous_attempt = predecessor
            .ranges
            .iter()
            .find(|item| item.range.role == 33 && item.range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if attempt.abi != 2
            || attempt.instance != self.successor.instance
            || attempt.base_word != base.publication_word
            || attempt.next_word != self.successor.word
            || attempt.logical_digest != self.successor.logical_digest
            || attempt.receipt_digest != attempt_range.logical_record_digest()?
            || attempt.previous_attempt_digest != previous_attempt.logical_record_digest()?
            || attempt.replay_head_digest != self.range(27)?.logical_record_digest()?
            || attempt.intent_head_digest != self.range(30)?.logical_record_digest()?
            || attempt.acknowledgement_head_digest != self.range(32)?.logical_record_digest()?
            || self.successor.state_digest != self.state_digest()?
        {
            return Err(publication_input_error(
                "replay evidence differs from its whole native attempt and state links",
            ));
        }
        let no_draw =
            attempt.action_receipts_digest == Identity256::from_bytes(Sha256::digest([]).into());
        match (attempt.transition_kind, base.terminal, no_draw) {
            (1, 0, false) => Ok(SemanticTransitionKind::Proposal),
            (2, 0, true) => Ok(SemanticTransitionKind::Recompute),
            (3, 1, true) => Ok(SemanticTransitionKind::Drain),
            (4, 0, true) => Ok(SemanticTransitionKind::Update),
            _ => Err(publication_input_error(
                "replay attempt cannot follow this predecessor's native terminal state",
            )),
        }
    }

    fn validate_observed(
        &self,
        predecessor: &PublicationMaterial,
        bank: &PublicationBank,
        coverage: &PublicationMaterialRange,
        codebook: &PublicationMaterialRange,
    ) -> Result<(), SemanticTransitionError> {
        let kind = self.validate(predecessor)?;
        let base = predecessor.bank.header;
        let header = bank.header;
        let draws = if kind == SemanticTransitionKind::Proposal {
            COMPONENT_COUNT
        } else {
            0
        };
        let proposal = base
            .proposal
            .checked_add(u64::from(draws != 0))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        if header.abi != 1
            || header.instance != self.successor.instance
            || header.publication_word != self.successor.word
            || header.base_word != base.publication_word
            || header.sealed_epoch != self.successor.word >> 1
            || header.logical_digest != self.successor.logical_digest
            || header.state_digest != self.successor.state_digest
            || header.proposal != proposal
            || bank.state.proposal != base.proposal
            || bank.state.next_proposal != proposal
            || bank.state.blocks != draws as u64
            || bank.state.status != 0
            || (kind == SemanticTransitionKind::Drain && header.terminal != 2)
            || (kind == SemanticTransitionKind::Recompute && header.terminal != 0)
            || (kind == SemanticTransitionKind::Proposal && header.terminal > 1)
        {
            return Err(publication_input_error(
                "replay evidence does not describe the actual acquired native transition",
            ));
        }
        let attempt = self.range(33)?.attempt()?;
        if coverage.range.role != 14
            || coverage.bytes.len() != size_of::<CompletionCoverage>()
            || coverage.original_record_digest() != coverage.range.digest
            || codebook.original_record_digest() != codebook.range.digest
        {
            return Err(publication_input_error(
                "replay evidence sources differ from their actual native seals",
            ));
        }
        // SAFETY: the exact coverage extent was checked and all ABI fields are integers.
        let completion = unsafe {
            std::ptr::read_unaligned(coverage.bytes.as_ptr().cast::<CompletionCoverage>())
        };
        let coverage_digest = coverage.logical_record_digest()?;
        let component_receipts_digest =
            publication_action_receipts_digest(codebook, &bank.receipts[..draws])?;
        let semantic_receipts_digest =
            publication_semantic_receipts_digest(&bank.state.semantic_receipts);
        let action_batch_valid = if kind == SemanticTransitionKind::Proposal {
            let batch = &bank.state.action_batch;
            let root = publication_action_batch_root(batch);
            batch.abi == 1
                && batch.proposal == bank.state.proposal
                && batch.stream_serial == bank.state.stream_serial
                && batch.family_id == u64::from(bank.state.family_id)
                && batch.action_law_generation == bank.state.catalogue_generation
                && batch.model_generation == u64::from(bank.state.model_generation)
                && batch.actor_eligible == bank.state.actor_eligible
                && batch.actor_eligible <= 1
                && batch.component_count == COMPONENT_COUNT as u64
                && batch.candidate_count == 3
                && batch.winner == bank.state.task_evaluation.winner
                && batch.total_return_bits == bank.state.task_evaluation.return_value as u64
                && batch.base_word == base.publication_word
                && batch.next_word == header.publication_word
                && batch.rng_base == bank.state.proposal * COMPONENT_COUNT as u64
                && batch.rng_span == COMPONENT_COUNT as u64
                && batch.rng_successor == bank.state.next_proposal * COMPONENT_COUNT as u64
                && batch.catalogue_digest == bank.state.catalogue_digest
                && batch.component_receipts_digest == component_receipts_digest
                && batch.semantic_receipts_digest == semantic_receipts_digest
                && batch.base_logical_digest == base.logical_digest
                && batch.execution_work == bank.state.execution_work
                && [0usize, 3, 6]
                    .into_iter()
                    .enumerate()
                    .all(|(candidate, receipt)| {
                        identity_words(*batch.candidate_roots[candidate].as_bytes())
                            == bank.state.semantic_receipts[receipt][16..20]
                    })
                && root == bank.state.action_batch_root
                && root == attempt.action_receipts_digest
        } else {
            bank.state.action_batch == SemanticActionBatchReceipt::default()
                && bank.state.action_batch_root == Identity256::default()
                && attempt.action_receipts_digest == component_receipts_digest
        };
        if completion.abi != 1
            || completion.instance != header.instance
            || completion.base_word != base.publication_word
            || completion.receipt_digest != coverage_digest
            || attempt.coverage_digest != coverage_digest
            || !action_batch_valid
            || attempt.semantic_receipts_digest != semantic_receipts_digest
        {
            return Err(publication_input_error(
                "whole native attempt differs from actual action, semantic or completion receipts",
            ));
        }
        Ok(())
    }
}

/// Owned cold replay inputs: complete predecessor material and the successor's
/// external native publication evidence. Hash consistency does not establish
/// historical execution, current rights, or permission to use a model.
pub struct SemanticReplayMaterial {
    predecessor: PublicationMaterial,
    evidence: PublicationReplayEvidence,
    kind: SemanticTransitionKind,
}

struct ReplayInitialPrefill {
    original: SemanticPublishedIdentity,
    content: Vec<u8>,
    recovery_referent: Option<Vec<u8>>,
}

impl SemanticReplayMaterial {
    fn completed_child_payload<'a>(
        &self,
        bytes: &'a [u8],
        kind: &[u8],
        expected_identity: Identity256,
        expected_owner: Identity256,
    ) -> Result<&'a [u8], SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(bytes);
        let magic = b"XLOG-COMPLETED-ACTION-CHILD\0";
        if reader
            .take(magic.len())
            .map_err(SemanticTransitionError::Semantic)?
            != magic
            || reader.u64().map_err(SemanticTransitionError::Semantic)? != 1
        {
            return Err(publication_input_error(
                "completed action child has another envelope",
            ));
        }
        let owner = reader.take(32).map_err(SemanticTransitionError::Semantic)?;
        if owner != expected_owner.as_bytes() {
            return Err(publication_input_error(
                "completed action child belongs to another action",
            ));
        }
        if reader.u64().map_err(SemanticTransitionError::Semantic)? != kind.len() as u64
            || reader
                .take(kind.len())
                .map_err(SemanticTransitionError::Semantic)?
                != kind
            || reader.u64().map_err(SemanticTransitionError::Semantic)? != 0
        {
            return Err(publication_input_error(
                "completed action child has another kind or ordinal",
            ));
        }
        let mut binding = b"xlog.completed-action-child.v1\0".to_vec();
        binding.extend_from_slice(owner);
        material_u64(&mut binding, kind.len() as u64);
        binding.extend_from_slice(kind);
        material_u64(&mut binding, 0);
        if Identity256::from_bytes(Sha256::digest(binding).into()) != expected_identity {
            return Err(publication_input_error(
                "completed action child identity differs from its owner",
            ));
        }
        let length = usize::try_from(reader.u64().map_err(SemanticTransitionError::Semantic)?)
            .map_err(|_| publication_input_error("completed action child exceeds this host"))?;
        let payload = reader
            .take(length)
            .map_err(SemanticTransitionError::Semantic)?;
        reader.finish().map_err(SemanticTransitionError::Semantic)?;
        Ok(payload)
    }

    fn read_initial_prefill_child(
        &self,
        bytes: &[u8],
        expected_identity: Identity256,
        expected_owner: Identity256,
    ) -> Result<ReplayInitialPrefill, SemanticTransitionError> {
        let payload = self.completed_child_payload(
            bytes,
            b"initial-prefill",
            expected_identity,
            expected_owner,
        )?;
        let mut payload = SemanticMaterialReader::new(payload);
        let magic = b"XLOG-INITIAL-PREFILL\0";
        if payload
            .take(magic.len())
            .map_err(SemanticTransitionError::Semantic)?
            != magic
            || payload.u64().map_err(SemanticTransitionError::Semantic)? != 2
        {
            return Err(publication_input_error(
                "initial prefill child has another body version",
            ));
        }
        let original = decode_publication_identity(&mut payload)?;
        let actual = decode_publication_identity(&mut payload)?;
        let header = self.predecessor.bank.header;
        if actual != self.predecessor_identity() {
            return Err(publication_input_error(
                "initial prefill child names another actual predecessor",
            ));
        }
        let recovery_referent = match payload.u8().map_err(SemanticTransitionError::Semantic)? {
            1 if original == actual => None,
            2 if original != actual
                && original.word == 0
                && actual.word == 0
                && original.instance != actual.instance
                && header.recovered_instance == original.instance
                && original.logical_digest == actual.logical_digest
                && original.state_digest == actual.state_digest =>
            {
                let length =
                    usize::try_from(payload.u64().map_err(SemanticTransitionError::Semantic)?)
                        .map_err(|_| {
                            publication_input_error("initial prefill referent exceeds this host")
                        })?;
                let referent = payload
                    .take(length)
                    .map_err(SemanticTransitionError::Semantic)?
                    .to_vec();
                if referent.is_empty() {
                    return Err(publication_input_error(
                        "recovered initial prefill has no source referent",
                    ));
                }
                Some(referent)
            }
            _ => {
                return Err(publication_input_error(
                    "initial prefill recovery chain is invalid",
                ))
            }
        };
        let content = payload.take_rest().to_vec();
        if content.is_empty() {
            return Err(publication_input_error(
                "initial prefill child has no original content",
            ));
        }
        let mut tail = SemanticMaterialReader::new(&content);
        tail.take(32 + 8 + 32)
            .map_err(SemanticTransitionError::Semantic)?;
        let task_epoch = tail.u64().map_err(SemanticTransitionError::Semantic)?;
        let mut read_identity = || -> Result<Identity256, SemanticTransitionError> {
            Ok(Identity256::from_bytes(
                tail.take(32)
                    .map_err(SemanticTransitionError::Semantic)?
                    .try_into()
                    .unwrap(),
            ))
        };
        let task_content = SemanticTaskContentIdentity {
            query: read_identity()?,
            theory_program: read_identity()?,
            result: read_identity()?,
        };
        CheckpointInitialPrefill {
            original,
            content: content.clone(),
            recovery_referent: None,
        }
        .verify_content(
            header.semantic_digest,
            header.model_generation,
            self.predecessor.contract.task_identity,
            task_epoch,
            task_content,
            header.prefix_extent,
        )?;
        Ok(ReplayInitialPrefill {
            original,
            content,
            recovery_referent,
        })
    }

    /// Return a recovery source reference only after checking the native child
    /// owner, its exact physical predecessor, and the restored-instance chain.
    pub fn initial_prefill_recovery_referent(
        &self,
        child: &[u8],
        child_identity: Identity256,
        action_identity: Identity256,
    ) -> Result<Option<Vec<u8>>, SemanticTransitionError> {
        Ok(self
            .read_initial_prefill_child(child, child_identity, action_identity)?
            .recovery_referent)
    }

    /// Read the late action's compact record through the same child envelope.
    /// The binding layer verifies every referent field and resolves its complete
    /// checkpoint through the existing bounded source resolver.
    pub fn pre_action_checkpoint_referent(
        &self,
        child: &[u8],
        child_identity: Identity256,
        action_identity: Identity256,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        let payload = self.completed_child_payload(
            child,
            b"pre-action-checkpoint",
            child_identity,
            action_identity,
        )?;
        if payload.len() != SemanticTransitionSession::CHECKPOINT_REFERENT_BYTES
            || payload.last() != Some(&3)
        {
            return Err(publication_input_error(
                "late checkpoint child has another pre-action phase or extent",
            ));
        }
        Ok(payload.to_vec())
    }

    /// Full resolved late source must equal this original replay's own acquired
    /// publication, including all model allocations, random state and arena.
    pub fn verify_pre_action_checkpoint_source(
        &self,
        native: &[u8],
        task_identity: Identity256,
        task_epoch: u64,
    ) -> Result<(), SemanticTransitionError> {
        if self.predecessor.contract.task_identity != task_identity
            || self.predecessor.bank.header.authority_generation != task_epoch
            || native != self.predecessor.encode()?
        {
            return Err(publication_input_error(
                "late checkpoint differs from this action's complete predecessor custody",
            ));
        }
        Ok(())
    }

    /// The compact reference is useful only if the full original checkpoint
    /// carries precisely the source publication and prefill bytes in this child.
    /// Keep the child bytes with their seal and the original checkpoint sections
    /// together; the task binding belongs to that original checkpoint.
    pub fn verify_initial_prefill_checkpoint_source(
        &self,
        (child, child_identity): (&[u8], Identity256),
        action_identity: Identity256,
        (original_native, original_prefill_section): (&[u8], &[u8]),
        task_identity: Identity256,
        task_epoch: u64,
        task_content: SemanticTaskContentIdentity,
    ) -> Result<(), SemanticTransitionError> {
        let replay = self.read_initial_prefill_child(child, child_identity, action_identity)?;
        if replay.recovery_referent.is_none()
            || !SemanticTransitionSession::verify_checkpoint_initial_prefill_source(
                original_prefill_section,
                original_native,
                task_identity,
                task_epoch,
                task_content,
                true,
            )?
        {
            return Err(publication_input_error(
                "initial prefill recovery has no original checkpoint source",
            ));
        }
        let original = CheckpointInitialPrefill::decode_section(original_prefill_section)?
            .ok_or_else(|| publication_input_error("original checkpoint has no initial prefill"))?;
        if replay.original != original.original || replay.content != original.content {
            return Err(publication_input_error(
                "recovered prefill differs from original checkpoint content",
            ));
        }
        Ok(())
    }

    /// Check the original coordinates and seals before any runtime relocation.
    pub fn decode(
        predecessor_bytes: &[u8],
        evidence_bytes: &[u8],
        expected_predecessor_logical: Identity256,
        expected_successor_logical: Identity256,
    ) -> Result<Self, SemanticTransitionError> {
        let predecessor = PublicationMaterial::decode(predecessor_bytes)?;
        let evidence = PublicationReplayEvidence::decode(evidence_bytes)?;
        if predecessor.bank.header.logical_digest != expected_predecessor_logical
            || evidence.successor.logical_digest != expected_successor_logical
        {
            return Err(publication_input_error(
                "replay native materials differ from the execution's logical identities",
            ));
        }
        let kind = evidence.validate(&predecessor)?;
        Ok(Self {
            predecessor,
            evidence,
            kind,
        })
    }

    pub fn predecessor_identity(&self) -> SemanticPublishedIdentity {
        let header = self.predecessor.bank.header;
        SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        }
    }

    pub fn successor_identity(&self) -> SemanticPublishedIdentity {
        self.evidence.successor
    }

    pub fn transition_kind(&self) -> SemanticTransitionKind {
        self.kind
    }

    pub fn training_view_origin(
        &self,
    ) -> Result<SemanticTrainingViewOrigin, SemanticTransitionError> {
        let header = self.predecessor.bank.header;
        Ok(SemanticTrainingViewOrigin {
            transition: self.kind,
            predecessor: self.predecessor_identity(),
            successor: self.successor_identity(),
            invocation: header.rng_binding()?,
            model_geometry_digest: header.model_geometry_digest,
            model_numerical_digest: header.model_numerical_digest,
        })
    }

    /// Original model-owned contribution, after complete material validation.
    /// Its consumer must validate the supported model format before restoring
    /// numerical state; these bytes are not current settings or an execution grant.
    pub fn model_numerical_mode(&self) -> Result<&[u8], SemanticTransitionError> {
        self.predecessor.model_numerical_mode()
    }

    /// Return the archived continuation decision after checking its native
    /// provenance root against the original complete predecessor. The caller
    /// must separately bind this root through the canonical reconstruction
    /// closure and check current rights; these bytes are not current authority.
    pub fn verify_provenance(&self, bytes: &[u8]) -> Result<Vec<u8>, SemanticTransitionError> {
        let provenance = PublicationReplayProvenance::decode(bytes)?;
        provenance.validate(&self.predecessor)?;
        Ok(provenance.decision.bytes)
    }
}

/// Complete native logical-state material inside an execution's material
/// closure. This is not an episode, a use grant, or proof of past publication.
struct PublicationMaterial {
    bank: PublicationBank,
    contract: PublicationContract,
    role_counts: [u64; 55],
    terminals: Vec<u64>,
    layouts: BTreeMap<(u64, u64), SemanticTensorLayout>,
    model_memory: ModelMemoryGeometry,
    model_allocations: Vec<Vec<u8>>,
    ranges: Vec<PublicationMaterialRange>,
    graph: SemanticRootMaterial,
    learning_phases: Vec<SemanticLearningPhaseRecord>,
}

/// Read-only delivery material from a sealed publication. Reading an
/// intent neither proves that the checkpoint was durably committed nor grants
/// authority to perform its external effect.
pub struct SemanticOutputIntent {
    pub stable_identity: Identity256,
    pub effect: Vec<u8>,
    pub payload: Vec<u8>,
}

fn acknowledgement_receipts(
    bytes: &[u8],
    capacity_bytes: usize,
) -> Result<Vec<(Identity256, Vec<u8>)>, SemanticTransitionError> {
    if bytes.len() < size_of::<AcknowledgementQueueHeader>() {
        return Err(publication_input_error(
            "acknowledgement queue has no native header",
        ));
    }
    // SAFETY: the checked, padding-free header contains only integral fields.
    let header = unsafe {
        bytes
            .as_ptr()
            .cast::<AcknowledgementQueueHeader>()
            .read_unaligned()
    };
    let declared_capacity = usize::try_from(header.capacity)
        .ok()
        .and_then(|count| count.checked_mul(size_of::<AcknowledgementEntry>()))
        .and_then(|entries| {
            usize::try_from(header.payload_capacity_bytes)
                .ok()?
                .checked_add(entries)
        })
        .and_then(|body| body.checked_add(size_of::<AcknowledgementQueueHeader>()));
    if header.abi != 1
        || header.count > header.capacity
        || declared_capacity != Some(capacity_bytes)
        || header.payload_used_bytes
            != (bytes.len() - size_of::<AcknowledgementQueueHeader>()) as u64
    {
        return Err(publication_input_error(
            "acknowledgement queue extent is inconsistent",
        ));
    }
    let mut cursor = size_of::<AcknowledgementQueueHeader>();
    let mut receipt_bytes = 0usize;
    let mut chain = Identity256::default();
    let mut seen = BTreeSet::new();
    let mut result = Vec::with_capacity(header.count as usize);
    for ordinal in 0..header.count {
        let entry_end = cursor
            .checked_add(size_of::<AcknowledgementEntry>())
            .filter(|&end| end <= bytes.len())
            .ok_or_else(|| publication_input_error("acknowledgement entry is incomplete"))?;
        // SAFETY: the exact entry extent was checked above.
        let entry = unsafe {
            bytes[cursor..]
                .as_ptr()
                .cast::<AcknowledgementEntry>()
                .read_unaligned()
        };
        let length = usize::try_from(entry.receipt_len)
            .map_err(|_| publication_input_error("acknowledgement receipt overflows this host"))?;
        let end = entry_end
            .checked_add(length)
            .filter(|&end| end <= bytes.len())
            .ok_or_else(|| publication_input_error("acknowledgement receipt is incomplete"))?;
        let receipt = &bytes[entry_end..end];
        receipt_bytes = receipt_bytes
            .checked_add(length)
            .ok_or_else(|| publication_input_error("acknowledgement receipt extent overflows"))?;
        let previous = chain;
        chain = publication_fold_digest(chain, 32, ordinal, entry.stable_identity);
        chain = publication_fold_digest(chain, 32, ordinal, entry.receipt_digest);
        if entry.stable_identity == Identity256::default()
            || !seen.insert(*entry.stable_identity.as_bytes())
            || entry.previous_chain != previous
            || entry.chain != chain
            || entry.receipt_digest != Identity256::from_bytes(Sha256::digest(receipt).into())
        {
            return Err(publication_input_error(
                "acknowledgement differs from its native chain",
            ));
        }
        result.push((entry.stable_identity, receipt.to_vec()));
        cursor = end;
    }
    if cursor != bytes.len()
        || chain != header.chain_head
        || receipt_bytes > header.payload_capacity_bytes as usize
    {
        return Err(publication_input_error(
            "acknowledgement chain does not cover its receipts",
        ));
    }
    Ok(result)
}

pub fn output_intents_from_publication_material(
    native_material: &[u8],
) -> Result<Vec<SemanticOutputIntent>, SemanticTransitionError> {
    let material = PublicationMaterial::decode(native_material)?;
    let entries = material
        .ranges
        .iter()
        .find(|item| (item.range.role, item.range.index) == (30, 0))
        .ok_or_else(|| publication_input_error("checkpoint omits its native intent queue"))?;
    let payload = material
        .ranges
        .iter()
        .find(|item| (item.range.role, item.range.index) == (31, 0))
        .ok_or_else(|| publication_input_error("checkpoint omits its native intent payload"))?;
    output_intents_from_ranges(entries, payload)
}

/// Resolve the current undelivered set from both sealed native queues. The
/// trusted receiver key authenticates every persisted acknowledgement before
/// any intent is omitted from a restored delivery retry.
pub fn pending_output_intents_from_publication_material(
    native_material: &[u8],
    recipient_id: Identity256,
    verification_key: &[u8; 32],
    expected_effect: &[u8],
) -> Result<Vec<SemanticOutputIntent>, SemanticTransitionError> {
    if recipient_id == Identity256::default() || verification_key.iter().all(|&byte| byte == 0) {
        return Err(publication_input_error(
            "pending intent projection requires the trusted receiver identity and key",
        ));
    }
    let material = PublicationMaterial::decode(native_material)?;
    let entries = material
        .ranges
        .iter()
        .find(|item| (item.range.role, item.range.index) == (30, 0))
        .ok_or_else(|| publication_input_error("checkpoint omits its native intent queue"))?;
    let payload = material
        .ranges
        .iter()
        .find(|item| (item.range.role, item.range.index) == (31, 0))
        .ok_or_else(|| publication_input_error("checkpoint omits its native intent payload"))?;
    let acknowledgements = material
        .ranges
        .iter()
        .find(|item| (item.range.role, item.range.index) == (32, 0))
        .ok_or_else(|| {
            publication_input_error("checkpoint omits its native acknowledgement queue")
        })?;
    let intents = output_intents_from_ranges(entries, payload)?;
    if expected_effect.is_empty()
        || intents
            .iter()
            .any(|intent| intent.effect.as_slice() != expected_effect)
    {
        return Err(publication_input_error(
            "checkpoint intent differs from the bound receiver effect",
        ));
    }
    let receipts = acknowledgement_receipts(&acknowledgements.bytes, acknowledgements.capacity)?;
    let mut acknowledged = BTreeSet::new();
    for (identity, receipt) in receipts {
        let intent = intents
            .iter()
            .find(|intent| intent.stable_identity == identity)
            .ok_or_else(|| {
                publication_input_error("checkpoint acknowledges an absent native intent")
            })?;
        verify_delivery_receipt(&receipt, intent, recipient_id, verification_key)?;
        acknowledged.insert(*identity.as_bytes());
    }
    Ok(intents
        .into_iter()
        .filter(|intent| !acknowledged.contains(intent.stable_identity.as_bytes()))
        .collect())
}

fn output_intents_from_ranges(
    entries: &PublicationMaterialRange,
    payload: &PublicationMaterialRange,
) -> Result<Vec<SemanticOutputIntent>, SemanticTransitionError> {
    if entries.bytes.len() < size_of::<IntentQueueHeader>() {
        return Err(publication_input_error(
            "checkpoint intent queue has no header",
        ));
    }
    // SAFETY: the checked byte extent contains an all-bit-valid scalar ABI record.
    let header =
        unsafe { std::ptr::read_unaligned(entries.bytes.as_ptr().cast::<IntentQueueHeader>()) };
    let entry_extent = usize::try_from(header.count)
        .ok()
        .and_then(|count| count.checked_mul(size_of::<IntentEntry>()))
        .and_then(|bytes| bytes.checked_add(size_of::<IntentQueueHeader>()));
    let capacity_extent = usize::try_from(header.capacity)
        .ok()
        .and_then(|count| count.checked_mul(size_of::<IntentEntry>()))
        .and_then(|bytes| bytes.checked_add(size_of::<IntentQueueHeader>()));
    if header.abi != 1
        || header.count > header.capacity
        || entry_extent != Some(entries.bytes.len())
        || capacity_extent.is_none_or(|extent| extent != entries.capacity)
        || header.payload_used_bytes != payload.bytes.len() as u64
        || header.payload_capacity_bytes != payload.capacity as u64
        || header.effect_offset_bytes != 0
        || header.effect_length_bytes == 0
        || header.effect_length_bytes > header.payload_used_bytes
    {
        return Err(publication_input_error(
            "checkpoint intent queue has inconsistent extents",
        ));
    }
    let effect_end = usize::try_from(header.effect_length_bytes)
        .map_err(|_| publication_input_error("checkpoint intent effect overflows this host"))?;
    let effect = &payload.bytes[..effect_end];
    let effect_digest = Identity256::from_bytes(Sha256::digest(effect).into());
    let mut cursor = effect_end;
    let mut chain = Identity256::default();
    let mut result = Vec::with_capacity(header.count as usize);
    for ordinal in 0..header.count {
        let offset = size_of::<IntentQueueHeader>() + ordinal as usize * size_of::<IntentEntry>();
        // SAFETY: the exact entry extent was checked above; the ABI is scalar-only.
        let entry = unsafe {
            std::ptr::read_unaligned(entries.bytes[offset..].as_ptr().cast::<IntentEntry>())
        };
        let length = usize::try_from(entry.payload_len).map_err(|_| {
            publication_input_error("checkpoint intent payload overflows this host")
        })?;
        let end = cursor
            .checked_add(length)
            .filter(|&end| end <= payload.bytes.len())
            .ok_or_else(|| publication_input_error("checkpoint intent payload is incomplete"))?;
        let content = &payload.bytes[cursor..end];
        let mut identity = Sha256::new();
        identity.update(0x786c6f67696e7431u64.to_le_bytes());
        for part in [
            entry.checkpoint_lineage,
            entry.base_logical,
            entry.effective_delta,
            entry.result_logical,
            entry.effect_digest,
            entry.payload_digest,
        ] {
            identity.update(part.as_bytes());
        }
        let stable_identity = Identity256::from_bytes(identity.finalize().into());
        let previous_chain = chain;
        chain = publication_fold_digest(chain, 30, ordinal, stable_identity);
        if entry.payload_offset != cursor as u64
            || entry.payload_len < 8
            || entry.effect_digest != effect_digest
            || entry.payload_digest != Identity256::from_bytes(Sha256::digest(content).into())
            || entry.previous_chain != previous_chain
            || entry.chain != chain
            || entry.stable_identity != stable_identity
            || stable_identity == Identity256::default()
        {
            return Err(publication_input_error(
                "checkpoint intent entry differs from its native chain",
            ));
        }
        result.push(SemanticOutputIntent {
            stable_identity,
            effect: effect.to_vec(),
            payload: content.to_vec(),
        });
        cursor = end;
    }
    if cursor != payload.bytes.len() || header.chain_head != chain {
        return Err(publication_input_error(
            "checkpoint intent chain does not cover its payload",
        ));
    }
    Ok(result)
}

fn verify_delivery_receipt(
    receipt: &[u8],
    intent: &SemanticOutputIntent,
    recipient_id: Identity256,
    verification_key: &[u8; 32],
) -> Result<Identity256, SemanticTransitionError> {
    const RECEIPT_DOMAIN: &[u8] = b"xlog.delivery.receipt.v1\0";
    const RECORD_DOMAIN: &[u8] = b"xlog.delivery.record.v1\0";
    let body_len = RECEIPT_DOMAIN
        .len()
        .checked_add(32 + 32 + 8 + 8 + 32)
        .and_then(|size| size.checked_add(intent.effect.len()))
        .and_then(|size| size.checked_add(intent.payload.len()))
        .ok_or_else(|| publication_input_error("delivery receipt extent overflows"))?;
    if recipient_id == Identity256::default()
        || body_len.checked_add(32) != Some(receipt.len())
        || !receipt.starts_with(RECEIPT_DOMAIN)
    {
        return Err(publication_input_error(
            "delivery receipt has another canonical extent or recipient",
        ));
    }
    let mut cursor = RECEIPT_DOMAIN.len();
    let identity_end = cursor + 32;
    if receipt[cursor..identity_end] != intent.stable_identity.as_bytes()[..] {
        return Err(publication_input_error(
            "delivery receipt has another native intent identity",
        ));
    }
    cursor = identity_end;
    let recipient_end = cursor + 32;
    if receipt[cursor..recipient_end] != recipient_id.as_bytes()[..] {
        return Err(publication_input_error(
            "delivery receipt has another trusted recipient",
        ));
    }
    cursor = recipient_end;
    let effect_length = u64::from_le_bytes(
        receipt[cursor..cursor + 8]
            .try_into()
            .expect("fixed extent"),
    );
    cursor += 8;
    if effect_length != intent.effect.len() as u64
        || receipt[cursor..cursor + intent.effect.len()] != intent.effect[..]
    {
        return Err(publication_input_error(
            "delivery receipt has another native effect",
        ));
    }
    cursor += intent.effect.len();
    let payload_length = u64::from_le_bytes(
        receipt[cursor..cursor + 8]
            .try_into()
            .expect("fixed extent"),
    );
    cursor += 8;
    if payload_length != intent.payload.len() as u64
        || receipt[cursor..cursor + intent.payload.len()] != intent.payload[..]
    {
        return Err(publication_input_error(
            "delivery receipt has another native payload",
        ));
    }
    cursor += intent.payload.len();
    let mut record = Sha256::new();
    record.update(RECORD_DOMAIN);
    record.update(&receipt[RECEIPT_DOMAIN.len()..cursor]);
    let expected_record: [u8; 32] = record.finalize().into();
    if receipt[cursor..cursor + 32] != expected_record {
        return Err(publication_input_error(
            "delivery receipt differs from its durable record digest",
        ));
    }
    let mut ipad = [0x36u8; 64];
    let mut opad = [0x5cu8; 64];
    for (index, &byte) in verification_key.iter().enumerate() {
        ipad[index] ^= byte;
        opad[index] ^= byte;
    }
    let mut inner = Sha256::new();
    inner.update(ipad);
    inner.update(&receipt[..body_len]);
    let mut outer = Sha256::new();
    outer.update(opad);
    outer.update(inner.finalize());
    let expected_mac: [u8; 32] = outer.finalize().into();
    let mut mismatch = 0u8;
    for (actual, expected) in receipt[body_len..].iter().zip(expected_mac) {
        mismatch |= *actual ^ expected;
    }
    if mismatch != 0 {
        return Err(publication_input_error(
            "delivery receipt MAC does not match the trusted receiver",
        ));
    }
    Ok(Identity256::from_bytes(Sha256::digest(receipt).into()))
}

#[cfg(test)]
mod delivery_receipt_tests {
    use super::*;

    #[test]
    fn exact_durable_receipt_binds_the_native_intent_and_receiver() {
        let intent = SemanticOutputIntent {
            stable_identity: Identity256::from_bytes([3; 32]),
            effect: b"deliver".to_vec(),
            payload: b"result".to_vec(),
        };
        let recipient = Identity256::from_bytes([5; 32]);
        let key = [7; 32];
        let mut receipt = b"xlog.delivery.receipt.v1\0".to_vec();
        receipt.extend_from_slice(intent.stable_identity.as_bytes());
        receipt.extend_from_slice(recipient.as_bytes());
        receipt.extend_from_slice(&(intent.effect.len() as u64).to_le_bytes());
        receipt.extend_from_slice(&intent.effect);
        receipt.extend_from_slice(&(intent.payload.len() as u64).to_le_bytes());
        receipt.extend_from_slice(&intent.payload);
        let mut record = Sha256::new();
        record.update(b"xlog.delivery.record.v1\0");
        record.update(&receipt[b"xlog.delivery.receipt.v1\0".len()..]);
        receipt.extend_from_slice(&record.finalize());
        let mut ipad = [0x36u8; 64];
        let mut opad = [0x5cu8; 64];
        for (index, byte) in key.iter().enumerate() {
            ipad[index] ^= byte;
            opad[index] ^= byte;
        }
        let mut inner = Sha256::new();
        inner.update(ipad);
        inner.update(&receipt);
        let mut outer = Sha256::new();
        outer.update(opad);
        outer.update(inner.finalize());
        receipt.extend_from_slice(&outer.finalize());
        assert_eq!(
            receipt.len(),
            169 + intent.effect.len() + intent.payload.len()
        );
        assert_eq!(
            verify_delivery_receipt(&receipt, &intent, recipient, &key).unwrap(),
            Identity256::from_bytes(Sha256::digest(&receipt).into())
        );
        assert!(verify_delivery_receipt(&receipt, &intent, recipient, &[8; 32]).is_err());
        assert!(
            verify_delivery_receipt(&receipt, &intent, Identity256::from_bytes([6; 32]), &key)
                .is_err()
        );
        receipt[100] ^= 1;
        assert!(verify_delivery_receipt(&receipt, &intent, recipient, &key).is_err());
    }

    #[test]
    fn acknowledgement_reserve_covers_every_full_receipt() {
        let required = 169 * 3 + 256 + 2 * 7;
        assert!(initial_acknowledgement_record(3, required - 1, 256, 7).is_err());
        let record = initial_acknowledgement_record(3, required, 256, 7).unwrap();
        assert_eq!(
            acknowledgement_receipts(&record.bytes, record.capacity_bytes)
                .unwrap()
                .len(),
            0
        );
        assert!(initial_acknowledgement_record(0, required, 256, 7).is_err());
    }
}

fn relocate_publication_codebooks(
    saved: &[u8],
    actual: &[u64],
) -> Result<Vec<u8>, SemanticTransitionError> {
    if actual.len() < 25
        || saved.len()
            != actual
                .len()
                .checked_mul(8)
                .ok_or(SemanticTransitionError::GenerationExhausted)?
    {
        return Err(publication_input_error(
            "restored codebook has another actual extent",
        ));
    }
    for (index, (saved, &actual)) in saved.as_chunks::<8>().0.iter().zip(actual).enumerate() {
        if !matches!(index, 14..=16 | 21..=24) && u64::from_le_bytes(*saved) != actual {
            return Err(publication_input_error(
                "restored codebook changes its admitted logical content or original base",
            ));
        }
    }
    Ok(publication_abi_bytes(actual))
}

fn publication_material_runtime() -> [u8; 32] {
    static IDENTITY: std::sync::OnceLock<[u8; 32]> = std::sync::OnceLock::new();
    *IDENTITY.get_or_init(|| {
        let mut hash = Sha256::new();
        hash.update(b"xlog.publication.material-runtime.v1\0");
        hash.update(include_bytes!("semantic_transition.rs"));
        hash.update(include_bytes!("semantic_transition/learning_phase.rs"));
        hash.update(include_bytes!("semantic_transition/prepared_replay.rs"));
        #[cfg(feature = "semantic-policy")]
        hash.update(include_bytes!("semantic_transition/model_evaluation.rs"));
        hash.update(include_bytes!("../kernels/semantic_transition.cu"));
        let policy_identity: [u8; 32] =
            include!(concat!(env!("OUT_DIR"), "/semantic_policy_identity.rs"));
        hash.update(policy_identity);
        #[cfg(feature = "semantic-policy")]
        hash.update(include_bytes!("../kernels/semantic_policy_binding.cuh"));
        hash.update(include_bytes!("../kernels/semantic_policy_domains.cuh"));
        hash.update(include_bytes!("semantic_hypergraph.rs"));
        hash.update(include_bytes!("../kernels/semantic_hypergraph.cu"));
        hash.finalize().into()
    })
}

const RUNTIME_CONTRACT_MAGIC: &[u8] = b"XLOG-PUBLICATION-RUNTIME\0";

/// Portable projection of the actual cold publication envelope. Mutable
/// extents, active rows, bank/instance identities and executable addresses do
/// not belong here. The original model contribution is retained in full.
fn runtime_contract_bytes(
    contract: PublicationContract,
    counts: &[u64; 55],
    terminals: &[u64],
    layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    capacities: &[(u64, u64, usize)],
    model_mode: &[u8],
    model_memory: &ModelMemoryGeometry,
) -> Result<Vec<u8>, SemanticTransitionError> {
    if model_mode.is_empty() || model_mode.len() > 16 * 1024 * 1024 {
        return Err(publication_input_error(
            "runtime contract requires the complete bounded model numerical mode",
        ));
    }
    let mut bytes = RUNTIME_CONTRACT_MAGIC.to_vec();
    material_u32(&mut bytes, 1);
    bytes.extend_from_slice(&publication_material_runtime());
    material_bytes(&mut bytes, model_mode).map_err(SemanticTransitionError::Semantic)?;
    for field in [
        contract.abi,
        contract.range_capacity,
        contract.prefix_capacity,
        contract.window_capacity,
        contract.feedback_capacity,
        contract.max_position,
        contract.pad_token,
        contract.terminal_token_count,
        contract.final_intent_payload_bytes,
        contract.model_generation,
        contract.policy_generation,
        contract.authority_generation,
        contract.role_count,
    ] {
        material_u64(&mut bytes, field);
    }
    let model = contract.model_contract_layout;
    for field in [
        model.schema_begin,
        model.schema_bytes,
        model.schema_digest_offset,
        model.generation_offset,
        model.numerical_digest_offset,
        model.identity_offset,
    ] {
        material_u64(&mut bytes, field);
    }
    for identity in [
        contract.task_identity,
        contract.topology_identity,
        contract.table_identity,
    ] {
        bytes.extend_from_slice(identity.as_bytes());
    }
    for &count in counts {
        material_u64(&mut bytes, count);
    }
    for &token in terminals {
        material_u64(&mut bytes, token);
    }
    material_u64(&mut bytes, layouts.len() as u64);
    for layout in layouts.values() {
        for field in [
            layout.role,
            layout.index,
            layout.element_bytes,
            layout.scalar_type,
            layout.rank,
            layout.logical_axis,
        ]
        .into_iter()
        .chain(layout.dimensions)
        .chain(layout.strides_bytes)
        {
            material_u64(&mut bytes, field);
        }
    }
    material_u64(&mut bytes, capacities.len() as u64);
    for &(role, index, capacity) in capacities {
        for field in [role, index, capacity as u64] {
            material_u64(&mut bytes, field);
        }
    }
    model_memory.encode_into(&mut bytes)?;
    Ok(bytes)
}

#[expect(
    clippy::too_many_arguments,
    reason = "the authenticated model mode is defined by independent publication owners"
)]
fn verified_runtime_model_mode<'a>(
    bytes: &'a [u8],
    contract: PublicationContract,
    counts: &[u64; 55],
    terminals: &[u64],
    layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    capacities: &[(u64, u64, usize)],
    table: &PublicationMaterialRange,
    model_memory: &ModelMemoryGeometry,
) -> Result<&'a [u8], SemanticTransitionError> {
    // The host layout map is not evidence of published device bytes: public
    // record aliases retain the actual mutable allocation. Authenticate that
    // parent's entire original table, including its active-row state, first.
    if (table.range.role, table.range.index, table.range.generation) != (55, 0, 1)
        || table.range.length_bytes != table.bytes.len() as u64
        || table.bytes.len() > table.capacity
        || table.original_record_digest() != table.range.digest
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let (_, actual_layouts, _) = decode_tensor_table(&table.bytes)?;
    if actual_layouts != layouts.values().copied().collect::<Vec<_>>() {
        return Err(publication_input_error(
            "publication material layout differs from its sealed table",
        ));
    }
    let mut reader = SemanticMaterialReader::new(bytes);
    if reader
        .take(RUNTIME_CONTRACT_MAGIC.len())
        .map_err(SemanticTransitionError::Semantic)?
        != RUNTIME_CONTRACT_MAGIC
        || reader.u32().map_err(SemanticTransitionError::Semantic)? != 1
        || reader.take(32).map_err(SemanticTransitionError::Semantic)?
            != publication_material_runtime()
    {
        return Err(publication_input_error(
            "unsupported native runtime contract format or identity",
        ));
    }
    let mode = reader.bytes().map_err(SemanticTransitionError::Semantic)?;
    // Comparing the complete explicit encoding validates the suffix, including
    // its exact length and all cold fields. Never overwrite the saved record.
    if runtime_contract_bytes(
        contract,
        counts,
        terminals,
        layouts,
        capacities,
        mode,
        model_memory,
    )? != bytes
    {
        return Err(publication_input_error(
            "runtime contract differs from actual cold publication state",
        ));
    }
    Ok(mode)
}

fn initial_runtime_contract_record(
    contract: PublicationContract,
    counts: &[u64; 55],
    terminals: &[u64],
    layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    mut capacities: Vec<(u64, u64, usize)>,
    model_mode: &[u8],
    model_memory: &ModelMemoryGeometry,
) -> Result<SemanticStateRecord, SemanticTransitionError> {
    if capacities.iter().any(|&(role, _, _)| role == 43) || counts[42] != 1 {
        return Err(publication_input_error(
            "runtime contract is generated exactly once by the native owner",
        ));
    }
    capacities.push((43, 0, 0));
    capacities.sort_by_key(|&(role, index, _)| (role, index));
    if capacities.len() != validate_publication_counts(counts)?
        || contract.range_capacity != capacities.len() as u64
    {
        return Err(publication_input_error(
            "runtime capacity roster differs from the actual publication directory",
        ));
    }
    // Only the value of a fixed-width capacity cell changes between passes.
    let capacity = runtime_contract_bytes(
        contract,
        counts,
        terminals,
        layouts,
        &capacities,
        model_mode,
        model_memory,
    )?
    .len();
    capacities.iter_mut().find(|entry| entry.0 == 43).unwrap().2 = capacity;
    let bytes = runtime_contract_bytes(
        contract,
        counts,
        terminals,
        layouts,
        &capacities,
        model_mode,
        model_memory,
    )?;
    debug_assert_eq!(bytes.len(), capacity);
    Ok(SemanticStateRecord {
        role: SemanticStateRole::RuntimeContract,
        index: 0,
        capacity_bytes: capacity,
        bytes,
    })
}

// SAFETY: callers below name only fixed publication ABI records containing
// integer/IEEE scalar fields with all bit patterns valid. The exact ABI size is
// checked before reading; no pointer-bearing control records enter this codec.
unsafe fn publication_material_record<T: Copy>(
    reader: &mut SemanticMaterialReader<'_>,
) -> Result<T, SemanticTransitionError> {
    let bytes = reader.bytes().map_err(SemanticTransitionError::Semantic)?;
    if bytes.len() != size_of::<T>() {
        return Err(publication_input_error(
            "publication material record has another ABI extent",
        ));
    }
    Ok(unsafe { std::ptr::read_unaligned(bytes.as_ptr().cast::<T>()) })
}

impl PublicationMaterial {
    fn model_numerical_mode(&self) -> Result<&[u8], SemanticTransitionError> {
        let record = self
            .ranges
            .iter()
            .find(|item| item.range.role == 43 && item.range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let table = self
            .ranges
            .iter()
            .find(|item| item.range.role == 55 && item.range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let capacities = self
            .ranges
            .iter()
            .map(|item| (item.range.role, item.range.index, item.capacity))
            .collect::<Vec<_>>();
        verified_runtime_model_mode(
            &record.bytes,
            self.contract,
            &self.role_counts,
            &self.terminals,
            &self.layouts,
            &capacities,
            table,
            &self.model_memory,
        )
    }

    fn encode(&self) -> Result<Vec<u8>, SemanticTransitionError> {
        self.validate()?;
        let mut bytes = b"XLOG-PUBLICATION-MATERIAL\0".to_vec();
        material_u32(&mut bytes, 3);
        bytes.extend_from_slice(&publication_material_runtime());
        material_bytes(
            &mut bytes,
            &self
                .graph
                .encode()
                .map_err(SemanticTransitionError::Semantic)?,
        )
        .map_err(SemanticTransitionError::Semantic)?;
        for record in [
            publication_abi_bytes(&[self.bank]),
            publication_abi_bytes(&[self.contract]),
            publication_abi_bytes(&self.role_counts),
            publication_abi_bytes(&self.terminals),
        ] {
            material_bytes(&mut bytes, &record).map_err(SemanticTransitionError::Semantic)?;
        }
        material_u32(
            &mut bytes,
            u32::try_from(self.layouts.len())
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
        );
        for layout in self.layouts.values() {
            material_bytes(&mut bytes, &publication_abi_bytes(&[*layout]))
                .map_err(SemanticTransitionError::Semantic)?;
        }
        self.model_memory.encode_into(&mut bytes)?;
        for allocation in &self.model_allocations {
            material_bytes(&mut bytes, allocation).map_err(SemanticTransitionError::Semantic)?;
        }
        material_u32(
            &mut bytes,
            u32::try_from(self.ranges.len())
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
        );
        for range in &self.ranges {
            if matches!(range.range.role, 18..=25) {
                // Model bytes occur once per full backing allocation, including
                // padding and cells outside any individual typed view.
                material_bytes(&mut bytes, &publication_abi_bytes(&[range.range]))
                    .map_err(SemanticTransitionError::Semantic)?;
                material_u64(&mut bytes, range.capacity as u64);
            } else {
                range.encode_into(&mut bytes)?;
            }
        }
        learning_phase::encode_history(&self.learning_phases, &mut bytes)?;
        Ok(bytes)
    }

    fn decode(bytes: &[u8]) -> Result<Self, SemanticTransitionError> {
        let mut reader = SemanticMaterialReader::new(bytes);
        if reader.take(26).map_err(SemanticTransitionError::Semantic)?
            != b"XLOG-PUBLICATION-MATERIAL\0"
            || reader.u32().map_err(SemanticTransitionError::Semantic)? != 3
            || reader.take(32).map_err(SemanticTransitionError::Semantic)?
                != publication_material_runtime()
        {
            return Err(publication_input_error(
                "publication material requires its exact pinned native runtime",
            ));
        }
        let graph_bytes = reader.bytes().map_err(SemanticTransitionError::Semantic)?;
        let limit = u32::try_from(graph_bytes.len()).unwrap_or(u32::MAX);
        let graph = SemanticRootMaterial::decode(
            graph_bytes,
            SemanticAdmissionLimits {
                max_records: limit,
                max_terms: limit,
                max_references: limit,
                max_utf8_bytes: graph_bytes.len(),
            },
        )
        .map_err(SemanticTransitionError::Semantic)?;
        // SAFETY: these fixed ABI records contain only all-bit-valid scalars.
        let bank = unsafe { publication_material_record::<PublicationBank>(&mut reader)? };
        let contract = unsafe { publication_material_record::<PublicationContract>(&mut reader)? };
        let role_counts = unsafe { publication_material_record::<[u64; 55]>(&mut reader)? };
        let terminal_bytes = reader.bytes().map_err(SemanticTransitionError::Semantic)?;
        if terminal_bytes.len() % 8 != 0 {
            return Err(publication_input_error(
                "publication terminal material is not integral",
            ));
        }
        let terminals = terminal_bytes
            .as_chunks::<8>()
            .0
            .iter()
            .map(|item| u64::from_le_bytes(*item))
            .collect();
        let count = reader
            .count(4 + size_of::<SemanticTensorLayout>())
            .map_err(SemanticTransitionError::Semantic)?;
        let mut layouts = BTreeMap::new();
        let mut previous = None;
        for _ in 0..count {
            // SAFETY: the tensor-layout ABI contains only integer fields.
            let layout =
                unsafe { publication_material_record::<SemanticTensorLayout>(&mut reader)? };
            let key = (layout.role, layout.index);
            if previous.is_some_and(|previous| previous >= key) {
                return Err(publication_input_error(
                    "publication material tensor layouts are not in canonical order",
                ));
            }
            previous = Some(key);
            layouts.insert(key, layout);
        }
        let model_memory = ModelMemoryGeometry::decode_from(&mut reader)?;
        model_memory.validate(&layouts)?;
        let mut model_allocations = Vec::new();
        for &extent in &model_memory.allocation_bytes {
            let allocation = reader.bytes().map_err(SemanticTransitionError::Semantic)?;
            if allocation.len() as u64 != extent {
                return Err(publication_input_error(
                    "publication material truncates a complete model backing allocation",
                ));
            }
            model_allocations.push(allocation.to_vec());
        }
        let count = reader
            .count(12 + size_of::<PublicationRange>())
            .map_err(SemanticTransitionError::Semantic)?;
        let mut ranges = Vec::with_capacity(count);
        for _ in 0..count {
            // SAFETY: the range ABI contains only integer/digest fields.
            let range = unsafe { publication_material_record::<PublicationRange>(&mut reader)? };
            let capacity =
                usize::try_from(reader.u64().map_err(SemanticTransitionError::Semantic)?).map_err(
                    |_| publication_input_error("publication material range capacity overflows"),
                )?;
            let payload = if matches!(range.role, 18..=25) {
                let (allocation, offset) = model_memory.location(range.role, range.index)?;
                let end = usize::try_from(range.length_bytes)
                    .ok()
                    .and_then(|bytes| offset.checked_add(bytes))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                model_allocations[allocation]
                    .get(offset..end)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?
            } else {
                reader.bytes().map_err(SemanticTransitionError::Semantic)?
            };
            ranges.push(PublicationMaterialRange {
                range,
                capacity,
                bytes: payload.to_vec(),
            });
        }
        let learning_phases = learning_phase::decode_history(&mut reader)?;
        reader.finish().map_err(SemanticTransitionError::Semantic)?;
        let material = Self {
            bank,
            contract,
            role_counts,
            terminals,
            layouts,
            model_memory,
            model_allocations,
            ranges,
            graph,
            learning_phases,
        };
        material.validate()?;
        for range in &material.ranges {
            if !is_tensor_role(range.range.role)
                && range.original_record_digest() != range.range.digest
            {
                return Err(publication_input_error(
                    "publication material changes an originally sealed native record",
                ));
            }
        }
        if material.original_descriptor_digest() != material.bank.header.descriptor_digest {
            return Err(publication_input_error(
                "publication material differs from its original descriptor seal",
            ));
        }
        Ok(material)
    }

    // A retained successor carries the native attempt which published it.
    // This proves the selected publication has the recompute form without
    // inventing an application-side completion flag or retaining an old GPU
    // reader. Historical provenance still belongs to the trusted importer.
    fn require_current_model_caches(&self) -> Result<(), SemanticTransitionError> {
        let coverage = self
            .ranges
            .iter()
            .find(|r| (r.range.role, r.range.index) == (14, 0))
            .filter(|r| r.bytes.len() == size_of::<CompletionCoverage>())
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        // SAFETY: the exact-size, decoded native ABI contains integer records
        // only and permits unaligned retained checkpoint bytes.
        let coverage = unsafe {
            std::ptr::read_unaligned(coverage.bytes.as_ptr().cast::<CompletionCoverage>())
        };
        if coverage.abi != 1 || coverage.model_generation != self.bank.header.model_generation {
            return Err(publication_input_error(
                "effective model changed; original caches require a full recompute before use",
            ));
        }
        Ok(())
    }

    fn require_successful_recompute(&self) -> Result<(), SemanticTransitionError> {
        self.require_current_model_caches()?;
        let header = self.bank.header;
        let next_word = (header.base_word >> 1)
            .checked_add(1)
            .filter(|epoch| *epoch <= u64::MAX >> 1)
            .map(|epoch| (epoch << 1) | ((header.base_word & 1) ^ 1))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let successor = SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        };
        let ranges = REPLAY_EVIDENCE_ROLES
            .iter()
            .map(|&role| {
                self.ranges
                    .iter()
                    .find(|item| item.range.role == role && item.range.index == 0)
                    .cloned()
                    .ok_or(SemanticTransitionError::ObservationMismatch)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let evidence = PublicationReplayEvidence { successor, ranges };
        let attempt = evidence.range(33)?.attempt()?;
        let coverage = self
            .ranges
            .iter()
            .find(|item| item.range.role == 14 && item.range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if header.abi != 1
            || header.publication_word != next_word
            || header.terminal != 0
            || attempt.abi != 2
            || attempt.transition_kind != 2
            || attempt.instance != header.instance
            || attempt.base_word != header.base_word
            || attempt.next_word != header.publication_word
            || attempt.logical_digest != header.logical_digest
            || attempt.action_receipts_digest != Identity256::from_bytes(Sha256::digest([]).into())
            || attempt.coverage_digest != coverage.logical_record_digest()?
            || attempt.replay_head_digest != evidence.range(27)?.logical_record_digest()?
            || attempt.intent_head_digest != evidence.range(30)?.logical_record_digest()?
            || attempt.acknowledgement_head_digest != evidence.range(32)?.logical_record_digest()?
            || attempt.previous_attempt_digest == Identity256::default()
            || attempt.receipt_digest != evidence.range(33)?.logical_record_digest()?
            || evidence.state_digest()? != header.state_digest
        {
            return Err(publication_input_error(
                "selected publication has no sealed successful recompute completion",
            ));
        }
        Ok(())
    }

    // Match publication_descriptor_digest before any owner/slot relocation.
    // This unkeyed consistency seal is not proof of historical execution. The
    // native restore still hashes actual payloads, and the trusted importer
    // separately verifies the complete execution evidence and current rights.
    fn original_descriptor_digest(&self) -> Identity256 {
        let mut bank = self.bank;
        bank.header.abi = 1;
        bank.header.descriptor_digest = Identity256::default();
        let mut digest =
            Identity256::from_bytes(Sha256::digest(publication_abi_bytes(&[bank])).into());
        for material in &self.ranges {
            let range = material.range;
            let content =
                Identity256::from_bytes(Sha256::digest(publication_abi_bytes(&[range])).into());
            digest = publication_fold_digest(digest, range.role, range.index, content);
        }
        digest
    }

    fn validate(&self) -> Result<(), SemanticTransitionError> {
        self.model_memory.validate(&self.layouts)?;
        let model = self
            .ranges
            .iter()
            .find(|item| (item.range.role, item.range.index) == (44, 0))
            .ok_or_else(|| {
                publication_input_error("publication material lacks its complete model contract")
            })?;
        self.contract
            .model_contract_layout
            .validate(model.bytes.len() as u64)?;
        if self.bank.header.model_geometry_digest != self.model_memory.digest(&self.layouts)? {
            return Err(publication_input_error(
                "publication model geometry differs from its original sealed map",
            ));
        }
        if self.model_allocations.len() != self.model_memory.allocation_bytes.len()
            || self
                .model_allocations
                .iter()
                .zip(&self.model_memory.allocation_bytes)
                .any(|(bytes, &extent)| bytes.len() as u64 != extent)
        {
            return Err(publication_input_error(
                "publication material lacks complete model backing bytes",
            ));
        }
        learning_phase::validate_history(self)?;
        let mut model_slots = BTreeMap::new();
        let mut slot_allocations = BTreeMap::new();
        let backing_digests = self
            .model_allocations
            .iter()
            .map(|bytes| Identity256::from_bytes(Sha256::digest(bytes).into()))
            .collect::<Vec<_>>();
        for item in self
            .ranges
            .iter()
            .filter(|item| matches!(item.range.role, 18..=25))
        {
            let (allocation, offset) = self
                .model_memory
                .location(item.range.role, item.range.index)?;
            let bytes = &self.model_allocations[allocation];
            let end = offset
                .checked_add(item.bytes.len())
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if item.range.offset_bytes != offset as u64
                || item.capacity != bytes.len() - offset
                || bytes.get(offset..end) != Some(item.bytes.as_slice())
                || item.range.backing_digest != backing_digests[allocation]
                || model_slots
                    .insert(allocation, item.range.storage_slot)
                    .is_some_and(|slot| slot != item.range.storage_slot)
                || slot_allocations
                    .insert(item.range.storage_slot, allocation)
                    .is_some_and(|prior| prior != allocation)
            {
                return Err(publication_input_error(
                    "publication material changes model backing or view relationships",
                ));
            }
        }
        if self.ranges.iter().any(|item| {
            !matches!(item.range.role, 18..=25)
                && (slot_allocations.contains_key(&item.range.storage_slot)
                    || item.range.backing_digest != Identity256::default())
        }) {
            return Err(publication_input_error(
                "model backing aliases native control or cache storage",
            ));
        }
        let header = self.bank.header;
        let contract = self.contract;
        if !cfg!(target_endian = "little")
            || header.abi != 1
            || contract.abi != 1
            || header.sealed_epoch != header.publication_word >> 1
            || contract.terminal_tokens != 0
            || contract.role_counts != 0
            || contract.semantic_owner != 0
            || contract.window_capacity != 32
            || contract.role_count != 55
            || contract.terminal_token_count != self.terminals.len() as u64
            || contract.model_generation == 0
            || header.model_generation < contract.model_generation
            || u32::try_from(header.model_generation).is_err()
            || header.authority_generation != contract.authority_generation
            || header.semantic_digest.as_bytes() != &self.graph.digest
            || header.semantic_extents != self.graph.extents.map(u64::from)
            || validate_publication_counts(&self.role_counts)? != self.ranges.len()
            || header.range_count != self.ranges.len() as u64
            || contract.range_capacity != header.range_count
        {
            return Err(publication_input_error(
                "publication material header or graph differs from its complete owned state",
            ));
        }
        let mut ranges = self.ranges.iter();
        for (ordinal, &count) in self.role_counts.iter().enumerate() {
            let role = ordinal as u64 + 1;
            for index in 0..count {
                let item = ranges
                    .next()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                if (item.range.role, item.range.index) != (role, index)
                    || item.range.generation != 1
                    || item.range.length_bytes != item.bytes.len() as u64
                    || (item.capacity == 0
                        && !self
                            .layouts
                            .get(&(role, index))
                            .is_some_and(empty_model_tensor_layout))
                    || item.bytes.len() > item.capacity
                    || item.range.logical_begin > item.range.logical_end
                {
                    return Err(publication_input_error(
                        "publication material omits, reorders or changes a reachable range",
                    ));
                }
                if is_tensor_role(role) {
                    let layout = self.layouts.get(&(role, index)).ok_or_else(|| {
                        publication_input_error("publication material omits a tensor layout")
                    })?;
                    if tensor_layout_bytes(layout)? > item.capacity
                        || (empty_model_tensor_layout(layout)
                            && (item.range.logical_begin != 0 || item.range.logical_end != 0))
                    {
                        return Err(publication_input_error(
                            "publication material tensor exceeds its actual capacity",
                        ));
                    }
                } else if self.layouts.contains_key(&(role, index)) {
                    return Err(publication_input_error(
                        "publication material gives a tensor layout to a native record",
                    ));
                }
            }
        }
        if self.layouts.len()
            != self
                .ranges
                .iter()
                .filter(|item| is_tensor_role(item.range.role))
                .count()
        {
            return Err(publication_input_error(
                "publication material has an undeclared tensor layout",
            ));
        }
        let acknowledgements = self
            .ranges
            .iter()
            .find(|item| (item.range.role, item.range.index) == (32, 0))
            .ok_or_else(|| {
                publication_input_error("publication material omits its acknowledgement queue")
            })?;
        let receipts =
            acknowledgement_receipts(&acknowledgements.bytes, acknowledgements.capacity)?;
        if !receipts.is_empty() {
            let entries = self
                .ranges
                .iter()
                .find(|item| (item.range.role, item.range.index) == (30, 0))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let payload = self
                .ranges
                .iter()
                .find(|item| (item.range.role, item.range.index) == (31, 0))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let intents = output_intents_from_ranges(entries, payload)?;
            if receipts.iter().any(|(identity, _)| {
                !intents
                    .iter()
                    .any(|intent| intent.stable_identity == *identity)
            }) {
                return Err(publication_input_error(
                    "publication acknowledges an absent native intent",
                ));
            }
        }
        self.model_numerical_mode()?;
        Ok(())
    }
}

struct PublicationStorage {
    control: TrackedCudaSlice<PublicationControl>,
    banks: [TrackedCudaSlice<PublicationBank>; 2],
    directories: [TrackedCudaSlice<PublicationRange>; 2],
    storage: TrackedCudaSlice<PublicationStorageEntry>,
    contract: TrackedCudaSlice<PublicationContract>,
    role_counts: TrackedCudaSlice<PublicationRoleCount>,
    terminals: TrackedCudaSlice<u64>,
    continuation: TrackedCudaSlice<PendingContinuation>,
    continuation_directory: TrackedCudaSlice<PublicationRange>,
    allocations: Vec<TrackedCudaSlice<u8>>,
    model_memory: ModelMemoryGeometry,
    physical_parameter_roster: Option<Vec<String>>,
    model_slots: Vec<[usize; 2]>,
    bank_templates: [Vec<PublicationRange>; 2],
    continuation_templates: Vec<PublicationRange>,
    layouts: BTreeMap<(u64, u64), SemanticTensorLayout>,
    contract_value: PublicationContract,
    instance: Identity256,
}

fn allocate_publication<T: DeviceRepr>(
    provider: &CudaKernelProvider,
    count: usize,
) -> Result<TrackedCudaSlice<T>, SemanticTransitionError> {
    provider
        .memory()
        .alloc::<T>(count)
        .map_err(|error| runtime_error("publication allocation", error))
}

fn upload_publication<T: DeviceRepr>(
    provider: &CudaKernelProvider,
    values: &[T],
    destination: &TrackedCudaSlice<T>,
) -> Result<(), SemanticTransitionError> {
    let mut destination = destination.view();
    provider
        .htod_launch_metadata_sync_copy_into(values, &mut destination)
        .map_err(|error| runtime_error("publication cold metadata upload", error))
}

#[cfg(feature = "semantic-policy")]
fn account_tracked_allocation<T: cudarc::driver::DeviceRepr>(
    allocations: &mut Vec<DeviceAllocationProvenance>,
    slice: &TrackedCudaSlice<T>,
) -> Result<(), SemanticTransitionError> {
    let provenance = slice
        .view()
        .allocation_provenance()
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    if !allocations
        .iter()
        .any(|known| provenance.same_allocation(known))
    {
        allocations.push(provenance);
    }
    Ok(())
}

#[cfg(feature = "semantic-policy")]
fn accounted_tracked_bytes(
    allocations: Vec<DeviceAllocationProvenance>,
) -> Result<u64, SemanticTransitionError> {
    allocations.into_iter().try_fold(0u64, |total, allocation| {
        total
            .checked_add(allocation.allocation_bytes())
            .ok_or(SemanticTransitionError::GenerationExhausted)
    })
}

impl PublicationStorage {
    fn continuation_block_contract(
        &self,
        kind: SemanticTransitionKind,
        input: &SemanticContinuationInput,
        prepared: bool,
    ) -> Result<(Option<usize>, Identity256, Identity256), SemanticTransitionError> {
        let expected = if kind == SemanticTransitionKind::Proposal {
            self.physical_parameter_roster.as_ref().map(Vec::len)
        } else {
            None
        };
        let host_identities = expected.is_some() && !prepared;
        if input.numerical_blocks.is_some() != expected.is_some()
            || input.model_schema_digest.is_some() != host_identities
            || input.model_identity.is_some() != host_identities
        {
            return Err(publication_input_error(
                "proposal block bounds require their original roster; only acquired replay accepts host model identities",
            ));
        }
        let schema = input.model_schema_digest.unwrap_or_default();
        let identity = input.model_identity.unwrap_or_default();
        if host_identities
            && (schema == Identity256::default() || identity == Identity256::default())
        {
            return Err(publication_input_error(
                "proposal block bounds require nonzero original model identities",
            ));
        }
        Ok((expected, schema, identity))
    }

    #[cfg(feature = "semantic-policy")]
    fn accounted_allocation_bytes(&self) -> Result<u64, SemanticTransitionError> {
        let mut allocations = Vec::new();
        account_tracked_allocation(&mut allocations, &self.control)?;
        for bank in &self.banks {
            account_tracked_allocation(&mut allocations, bank)?;
        }
        for directory in &self.directories {
            account_tracked_allocation(&mut allocations, directory)?;
        }
        account_tracked_allocation(&mut allocations, &self.storage)?;
        account_tracked_allocation(&mut allocations, &self.contract)?;
        account_tracked_allocation(&mut allocations, &self.role_counts)?;
        account_tracked_allocation(&mut allocations, &self.terminals)?;
        account_tracked_allocation(&mut allocations, &self.continuation)?;
        account_tracked_allocation(&mut allocations, &self.continuation_directory)?;
        for allocation in &self.allocations {
            account_tracked_allocation(&mut allocations, allocation)?;
        }
        accounted_tracked_bytes(allocations)
    }

    #[expect(
        clippy::too_many_arguments,
        reason = "the guard records each authenticated publication coordinate explicitly"
    )]
    fn enqueue_content_guard(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        reader: DeviceMemoryView<PublicationLease>,
        execute: &CudaFunction,
        role: u64,
        index: u64,
        layout: SemanticTensorLayout,
    ) -> Result<(), SemanticTransitionError> {
        let mut recorder = domain.new_strict_recorder();
        recorder.read(&reader);
        recorder.read(&self.control);
        recorder.read(&self.storage);
        recorder.read(&self.contract);
        for bank in &self.banks {
            recorder.read(bank);
        }
        for directory in &self.directories {
            recorder.read(directory);
        }
        for allocation in &self.allocations {
            recorder.read(allocation);
        }
        let arguments = (
            self.control.device_ptr_value(),
            role,
            index,
            layout,
            u64::from(is_tensor_role(role)),
            *reader.device_ptr(),
        );
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: the original device lease selects its actual directory;
            // every selectable bank, range, seal and allocation remains owned.
            unsafe {
                execute.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    #[expect(
        clippy::too_many_arguments,
        reason = "cold allocation consumes the complete independently owned publication contract"
    )]
    fn allocate(
        provider: &CudaKernelProvider,
        plans: &[PublicationAllocationPlan],
        layouts: BTreeMap<(u64, u64), SemanticTensorLayout>,
        model_memory: ModelMemoryGeometry,
        model_payloads: &[PublicationPayload],
        mut contract: PublicationContract,
        terminal_tokens: &[u64],
        instance: Identity256,
    ) -> Result<(Self, Vec<(usize, PublicationPayload)>), SemanticTransitionError> {
        let mut allocations = Vec::new();
        let mut bank_templates = [Vec::new(), Vec::new()];
        let mut uploads = Vec::new();
        model_memory.validate(&layouts)?;
        if model_payloads.len() != model_memory.allocation_bytes.len() {
            return Err(publication_input_error(
                "model backing upload roster differs from its complete memory map",
            ));
        }
        let physical_parameter_roster = plans
            .iter()
            .find(|plan| (plan.role, plan.index) == (44, 0))
            .and_then(|plan| match &plan.payload {
                PublicationPayload::Metadata(bytes) => Some(bytes.as_slice()),
                _ => None,
            })
            .map(|record| model_physical_parameter_roster(record, contract.model_contract_layout))
            .transpose()?
            .flatten();
        let mut model_slots = Vec::new();
        for (&bytes, payload) in model_memory.allocation_bytes.iter().zip(model_payloads) {
            let mut slots = [0; 2];
            for slot in &mut slots {
                *slot = allocations.len();
                allocations.push(allocate_publication::<u8>(provider, bytes as usize)?);
                uploads.push((*slot, payload.clone()));
            }
            model_slots.push(slots);
        }
        for plan in plans {
            if (plan.capacity == 0
                && !layouts
                    .get(&(plan.role, plan.index))
                    .is_some_and(empty_model_tensor_layout))
                || plan.length > plan.capacity
                || (layouts
                    .get(&(plan.role, plan.index))
                    .is_some_and(empty_model_tensor_layout)
                    && (plan.logical_begin != 0 || plan.logical_end != 0))
            {
                return Err(publication_input_error(
                    "owned publication allocation has invalid capacity",
                ));
            }
            let mut slot = 0;
            let model_view = if matches!(plan.role, 18..=25) {
                Some(model_memory.location(plan.role, plan.index)?)
            } else {
                None
            };
            for (bank, directory) in bank_templates.iter_mut().enumerate() {
                if let Some((allocation, offset)) = model_view {
                    slot = model_slots[allocation][bank];
                    if plan.capacity != allocations[slot].len() - offset {
                        return Err(publication_input_error(
                            "model range capacity differs from its actual backing view",
                        ));
                    }
                } else if bank == 0 || publication_mutable_role(plan.role) {
                    slot = allocations.len();
                    allocations.push(allocate_publication::<u8>(provider, plan.capacity)?);
                    uploads.push((slot, plan.payload.clone()));
                }
                directory.push(PublicationRange {
                    role: plan.role,
                    index: plan.index,
                    storage_slot: slot as u64,
                    generation: 1,
                    offset_bytes: model_view.map_or(0, |(_, offset)| offset as u64),
                    length_bytes: plan.length as u64,
                    logical_begin: plan.logical_begin,
                    logical_end: plan.logical_end,
                    digest: Identity256::default(),
                    backing_digest: Identity256::default(),
                });
            }
        }
        let pending_layouts = layouts
            .values()
            .filter(|layout| continuation_role(layout.role))
            .map(|layout| continuation_allocation_layout(*layout))
            .collect::<Result<Vec<_>, _>>()?;
        let pending_table = tensor_table_bytes(&pending_layouts, true, &[])?;
        let mut continuation_templates = Vec::new();
        for plan in plans.iter().filter(|plan| continuation_role(plan.role)) {
            let capacity = if plan.role == 1 {
                32 * size_of::<SemanticTextSlot>()
            } else if plan.role == 39 {
                plan.capacity
            } else if plan.role == 55 {
                tensor_table_capacity(pending_layouts.len(), 32 + contract.feedback_capacity)?
            } else {
                tensor_layout_bytes(&continuation_allocation_layout(
                    layouts[&(plan.role, plan.index)],
                )?)?
            };
            if capacity == 0 {
                return Err(publication_input_error(
                    "continuation destination has no actual capacity",
                ));
            }
            let slot = allocations.len();
            allocations.push(allocate_publication::<u8>(provider, capacity)?);
            let length = if plan.role == 55 {
                uploads.push((slot, PublicationPayload::Metadata(pending_table.clone())));
                pending_table.len()
            } else if matches!(plan.role, 1 | 39) {
                0
            } else {
                capacity
            };
            continuation_templates.push(PublicationRange {
                role: plan.role,
                index: plan.index,
                storage_slot: slot as u64,
                generation: 1,
                length_bytes: length as u64,
                ..PublicationRange::default()
            });
        }
        let terminals = allocate_publication::<u64>(provider, terminal_tokens.len())?;
        let role_counts = allocate_publication::<PublicationRoleCount>(provider, 55)?;
        contract.terminal_tokens = terminals.device_ptr_value();
        contract.role_counts = role_counts.device_ptr_value();
        let contract_value = contract;
        Ok((
            Self {
                control: allocate_publication(provider, 1)?,
                banks: [
                    allocate_publication(provider, 1)?,
                    allocate_publication(provider, 1)?,
                ],
                directories: [
                    allocate_publication(provider, plans.len())?,
                    allocate_publication(provider, plans.len())?,
                ],
                storage: allocate_publication(provider, allocations.len())?,
                contract: allocate_publication(provider, 1)?,
                role_counts,
                terminals,
                continuation: allocate_publication(provider, 1)?,
                continuation_directory: allocate_publication(
                    provider,
                    continuation_templates.len(),
                )?,
                allocations,
                model_memory,
                physical_parameter_roster,
                model_slots,
                bank_templates,
                continuation_templates,
                layouts,
                contract_value,
                instance,
            },
            uploads,
        ))
    }

    fn record(&self, recorder: &mut LaunchRecorder) {
        recorder.read_write(&self.control);
        for bank in &self.banks {
            recorder.read_write(bank);
        }
        for directory in &self.directories {
            recorder.read_write(directory);
        }
        recorder.read(&self.storage);
        recorder.read(&self.contract);
        recorder.read(&self.role_counts);
        recorder.read(&self.terminals);
        recorder.read_write(&self.continuation);
        recorder.read_write(&self.continuation_directory);
        for allocation in &self.allocations {
            recorder.read_write(allocation);
        }
    }
}

struct PreparedContinuation {
    storage: Arc<PublicationStorage>,
    reader: DeviceMemoryView<PublicationLease>,
    text_binding: Arc<TextBindingStorage>,
    sources: Vec<PreparedSemanticTensor>,
    copies: Vec<(u64, u64, usize)>,
    inputs: ContinuationInputs,
    training_selection: Option<DeviceMemoryView<SemanticTrainingViewSelection>>,
    execute: CudaFunction,
}

type ContinuationPayloadPlan = (
    Vec<(usize, PublicationPayload)>,
    BTreeMap<(u64, u64), SemanticTensorLayout>,
);

fn prepare_continuation_payloads(
    storage: &PublicationStorage,
    original: &[PreparedSemanticTensor],
    authority_decisions: &[u8],
    kind: SemanticTransitionKind,
) -> Result<ContinuationPayloadPlan, SemanticTransitionError> {
    let mut pending_layouts = BTreeMap::new();
    let mut inputs = BTreeMap::new();
    for tensor in original {
        let key = (tensor.layout.role, tensor.layout.index);
        let model = storage.layouts.get(&key).ok_or_else(|| {
            publication_input_error("continuation tensor has no cold model owner")
        })?;
        if !continuation_role(key.0) || !is_tensor_role(key.0) || inputs.contains_key(&key) {
            return Err(publication_input_error(
                "continuation tensor type or role differs from the model",
            ));
        }
        let destination = continuation_tensor_layout_for_kind(
            &tensor.layout,
            tensor.logical_begin,
            tensor.logical_end,
            model,
            kind,
        )?;
        pending_layouts.insert(key, destination);
        inputs.insert(key, tensor.clone());
    }
    let mut uploads = Vec::new();
    for range in &storage.continuation_templates {
        let key = (range.role, range.index);
        if matches!(range.role, 1 | 55) {
            continue;
        }
        let payload = if range.role == 39 {
            PublicationPayload::Metadata(authority_decisions.to_vec())
        } else {
            PublicationPayload::Tensor(inputs.remove(&key).ok_or_else(|| {
                publication_input_error("continuation omits an actual required forward tensor")
            })?)
        };
        let length = match &payload {
            PublicationPayload::Metadata(bytes) => bytes.len(),
            PublicationPayload::Tensor(_) => tensor_layout_bytes(&pending_layouts[&key])?,
            PublicationPayload::Uncomputed => {
                unreachable!("continuation accepts original computed tensors only")
            }
        };
        if length > storage.allocations[range.storage_slot as usize].len() {
            return Err(publication_input_error(
                "actual continuation exceeds its owned fixed destination capacity",
            ));
        }
        uploads.push((range.storage_slot as usize, payload));
    }
    if !inputs.is_empty() {
        return Err(publication_input_error(
            "continuation contains an undeclared tensor owner",
        ));
    }
    Ok((uploads, pending_layouts))
}

impl PreparedContinuation {
    // Cold geometry and owner preparation. Counts remain original device
    // pointers in inputs; this never snapshots their values or changes layout.
    #[expect(
        clippy::too_many_arguments,
        reason = "continuation preparation binds all retained producer and publication owners"
    )]
    fn prepare(
        provider: &CudaKernelProvider,
        storage: Arc<PublicationStorage>,
        reader: DeviceMemoryView<PublicationLease>,
        text_binding: Arc<TextBindingStorage>,
        inputs: ContinuationInputs,
        training_selection: Option<DeviceMemoryView<SemanticTrainingViewSelection>>,
        uploads: &[(usize, PublicationPayload)],
        layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    ) -> Result<Self, SemanticTransitionError> {
        let mut sources = Vec::new();
        let mut copies = Vec::new();
        for (slot, payload) in uploads {
            let PublicationPayload::Tensor(tensor) = payload else {
                continue;
            };
            let destination = storage
                .allocations
                .get(*slot)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if let Some(source) = &tensor.source {
                let layout = layouts
                    .get(&(tensor.layout.role, tensor.layout.index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                for (source_offset, destination_offset, bytes) in
                    tensor_copy_plan(&tensor.layout, layout)?
                {
                    if source_offset
                        .checked_add(bytes as u64)
                        .is_none_or(|end| end > source.len() as u64)
                        || destination_offset
                            .checked_add(bytes as u64)
                            .is_none_or(|end| end > destination.len() as u64)
                    {
                        return Err(SemanticTransitionError::ObservationMismatch);
                    }
                    let source = source
                        .device_ptr()
                        .checked_add(source_offset)
                        .ok_or(SemanticTransitionError::ObservationMismatch)?;
                    let destination = destination
                        .device_ptr_value()
                        .checked_add(destination_offset)
                        .ok_or(SemanticTransitionError::ObservationMismatch)?;
                    copies.push((source, destination, bytes));
                }
            }
            // Empty tensors retain their real producer token as well.
            sources.push(tensor.clone());
        }
        let execute = provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_publication_prepare_continuation",
            )
            .ok_or_else(|| {
                runtime_error("kernel lookup", "continuation preparation unavailable")
            })?;
        Ok(Self {
            storage,
            reader,
            text_binding,
            sources,
            copies,
            inputs,
            training_selection,
            execute,
        })
    }

    // Enqueue only: original source owners, fixed copy spans and the kernel
    // are already prepared. Authority upload and stream joins belong outside.
    fn enqueue(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
    ) -> Result<(), SemanticTransitionError> {
        let mut recorder = domain.new_strict_recorder();
        self.storage.record(&mut recorder);
        recorder.read(&self.reader);
        self.text_binding.record(&mut recorder);
        if let Some(selection) = &self.training_selection {
            recorder.read(selection);
        }
        for tensor in &self.sources {
            if let Some(source) = &tensor.source {
                recorder.read(source);
            }
        }
        let arguments = (
            self.storage.control.device_ptr_value(),
            *self.reader.device_ptr(),
            self.inputs,
        );
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            for &(source, destination, bytes) in &self.copies {
                // SAFETY: cold geometry bounds both addresses to the original
                // witnessed source and retained fixed destination allocation.
                unsafe {
                    sys::cuMemcpyDtoDAsync_v2(
                        destination,
                        source,
                        bytes,
                        enqueue.stream().cu_stream(),
                    )
                }
                .result()
                .map_err(|error| XlogError::Kernel(error.to_string()))?;
            }
            // SAFETY: the actual acquired reader, original service producers
            // and complete pending storage share this recorded lifetime.
            unsafe {
                self.execute.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }
}

struct PublishedReader {
    device: TrackedCudaSlice<PublicationLease>,
    aliases: Arc<()>,
    consumer_streams: BTreeSet<u64>,
}

#[repr(C)]
#[derive(Clone, Copy)]
struct PublicationStepInput {
    role: u64,
    index: u64,
    destination: u64,
    capacity_bytes: u64,
    backing: u64,
    backing_bytes: u64,
    layout: SemanticTensorLayout,
}

// SAFETY: the fixed CUDA ABI contains only u64 words and the checked tensor layout.
unsafe impl DeviceRepr for PublicationStepInput {}
const _: () = assert!(size_of::<PublicationStepInput>() == 160);

#[derive(Clone, Debug)]
struct StepInputBankPlan {
    storage_slot: usize,
    span: std::ops::Range<usize>,
}

#[derive(Clone)]
struct StepInputPlan {
    role: u64,
    index: u64,
    layout: SemanticTensorLayout,
    banks: [StepInputBankPlan; 2],
}

fn step_input_overlap(
    data: u64,
    bytes: usize,
    base: u64,
    capacity: usize,
) -> Result<bool, SemanticTransitionError> {
    let end = data
        .checked_add(bytes as u64)
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    let limit = base
        .checked_add(capacity as u64)
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    Ok(if bytes == 0 {
        data >= base && data < limit
    } else {
        data < limit && base < end
    })
}

fn plan_step_inputs(
    banks: &[Vec<PublicationRange>; 2],
    layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    prefix_capacity: u64,
    allocation_bytes: &[usize],
) -> Result<Vec<StepInputPlan>, SemanticTransitionError> {
    let mut expected = BTreeSet::from([(1, 0), (3, 0), (15, 0), (16, 0), (17, 0), (44, 0)]);
    expected.extend(
        banks[0]
            .iter()
            .filter(|range| matches!(range.role, 16 | 17))
            .map(|range| (range.role, range.index)),
    );
    for (&key, layout) in layouts
        .iter()
        .filter(|(key, _)| matches!(key.0, 4..=13 | 18..=25))
    {
        let model = matches!(key.0, 18..=25);
        let bytes = tensor_layout_bytes(layout)?;
        if key != (layout.role, layout.index)
            || (!model && (canonical_tensor_layout(*layout)? != *layout || bytes == 0))
            || (model && layout.logical_axis != u64::MAX)
        {
            return Err(publication_input_error(
                "step input must retain its original tensor layout",
            ));
        }
        expected.insert(key);
    }
    for role in (4..=13).chain(15..=25) {
        for (index, key) in expected.iter().filter(|key| key.0 == role).enumerate() {
            if key.1 != index as u64 {
                return Err(publication_input_error(
                    "step input tensor indexes must be contiguous",
                ));
            }
        }
    }
    for bank in banks {
        let actual = bank
            .iter()
            .filter(|range| matches!(range.role, 1 | 3..=13 | 15..=25 | 44))
            .map(|range| (range.role, range.index))
            .collect::<Vec<_>>();
        if actual.len() != expected.len()
            || actual.iter().copied().collect::<BTreeSet<_>>() != expected
        {
            return Err(publication_input_error(
                "step input banks must have the exact original input roster",
            ));
        }
    }
    let mut plan = Vec::with_capacity(expected.len());
    let mut spans = Vec::new();
    for (role, index) in expected {
        let ranges = banks.each_ref().map(|bank| {
            *bank
                .iter()
                .find(|range| (range.role, range.index) == (role, index))
                .expect("validated input roster")
        });
        let layout = if role == 1 {
            committed_prefix_layout(&ranges[0], prefix_capacity)?
        } else if matches!(role, 3 | 15..=17 | 44) {
            SemanticTensorLayout {
                role,
                index,
                scalar_type: 1,
                element_bytes: 1,
                rank: 1,
                logical_axis: u64::MAX,
                dimensions: [ranges[0].length_bytes, 0, 0, 0],
                strides_bytes: [1, 0, 0, 0],
            }
        } else {
            layouts[&(role, index)]
        };
        let bytes = tensor_layout_bytes(&layout)?;
        if (bytes == 0 && !matches!(role, 18..=25))
            || (role == 3 && ranges.iter().any(|range| range.length_bytes != 32))
        {
            return Err(publication_input_error(
                "step input has no complete fixed physical capacity",
            ));
        }
        if matches!(role, 15..=17)
            && ranges.iter().any(|range| {
                range.logical_begin != 0
                    || if role == 15 {
                        range.length_bytes % size_of::<RawFeedbackRecord>() as u64 != 0
                            || range.logical_end
                                > range.length_bytes / size_of::<RawFeedbackRecord>() as u64
                    } else {
                        range.logical_end != 0
                    }
            })
        {
            return Err(publication_input_error(
                "raw feedback input differs from its original record extent",
            ));
        }
        let mut resolved = Vec::with_capacity(2);
        for (bank, range) in ranges.iter().enumerate() {
            if role == 1 {
                committed_prefix_layout(range, prefix_capacity)?;
            }
            let slot = usize::try_from(range.storage_slot)
                .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
            let capacity = *allocation_bytes
                .get(slot)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let span = publication_export_span(range, &layout, capacity)?;
            if span.len() != bytes {
                return Err(publication_input_error(
                    "step input differs from its full typed capacity",
                ));
            }
            spans.push((bank, role, index, slot, span.clone()));
            resolved.push((slot, span, capacity));
        }
        if role == 1 && resolved[0] != resolved[1] {
            return Err(publication_input_error(
                "prefix step inputs must share their original capacity allocation",
            ));
        }
        if matches!(role, 4 | 5 | 15 | 18..=25 | 44)
            && (resolved[0].0 == resolved[1].0
                || resolved[0].1 != resolved[1].1
                || resolved[0].2 != resolved[1].2)
        {
            return Err(publication_input_error("bank-selected step inputs require disjoint banks with the same complete backing geometry"));
        }
        plan.push(StepInputPlan {
            role,
            index,
            layout,
            banks: resolved
                .into_iter()
                .map(
                    |(storage_slot, span, _allocation_bytes)| StepInputBankPlan {
                        storage_slot,
                        span,
                    },
                )
                .collect::<Vec<_>>()
                .try_into()
                .expect("two publication banks"),
        });
    }
    for (ordinal, (bank, role, index, slot, span)) in spans.iter().enumerate() {
        for (other_bank, other_role, other_index, other_slot, other_span) in &spans[..ordinal] {
            let same_shared = bank != other_bank
                && role == other_role
                && index == other_index
                && slot == other_slot
                && span == other_span
                && matches!(*role, 1 | 16 | 17);
            let same_model =
                bank == other_bank && matches!(*role, 18..=25) && matches!(*other_role, 18..=25);
            if slot == other_slot
                && span.start < other_span.end
                && other_span.start < span.end
                && !same_shared
                && !same_model
            {
                return Err(publication_input_error(
                    "step input caches and distinct tensor ranges must be isolated",
                ));
            }
        }
    }
    Ok(plan)
}

/// Fixed inputs are prepared without a host choice of publication bank. The
/// producer resolves the actual device lease and preserves its original seals.
struct PreparedStepInputs {
    storage: Arc<PublicationStorage>,
    reader: DeviceMemoryView<PublicationLease>,
    header: TrackedCudaSlice<PublicationHeader>,
    source: TrackedCudaSlice<SourceSlot>,
    ranges: TrackedCudaSlice<PublicationRange>,
    metadata_digests: TrackedCudaSlice<u64>,
    bindings: [TrackedCudaSlice<PublicationStepInput>; 2],
    binding_values: [Vec<PublicationStepInput>; 2],
    plans: Vec<StepInputPlan>,
    views: [BTreeMap<(u64, u64), DeviceMemoryView<u8>>; 2],
    private: Vec<TrackedCudaSlice<u8>>,
    execute: CudaFunction,
    guard: CudaFunction,
    completed_guard: CudaFunction,
}

impl PreparedStepInputs {
    fn plan(storage: &PublicationStorage) -> Result<Vec<StepInputPlan>, SemanticTransitionError> {
        plan_step_inputs(
            &storage.bank_templates,
            &storage.layouts,
            storage.contract_value.prefix_capacity,
            &storage
                .allocations
                .iter()
                .map(TrackedCudaSlice::len)
                .collect::<Vec<_>>(),
        )
    }

    fn allocation_bytes(plans: &[StepInputPlan]) -> Result<usize, SemanticTransitionError> {
        let fixed =
            size_of::<PublicationHeader>() + 32 * size_of::<SourceSlot>() + u64::BITS as usize;
        let bytes = plans
            .len()
            .checked_mul(size_of::<PublicationRange>() + 2 * size_of::<PublicationStepInput>())
            .and_then(|n| n.checked_add(fixed))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        plans
            .iter()
            .filter(|input| !matches!(input.role, 1 | 4 | 5 | 18..=25))
            .try_fold(bytes, |sum, input| {
                sum.checked_add(input.banks[0].span.len())
                    .ok_or(SemanticTransitionError::GenerationExhausted)
            })
    }

    fn allocate(
        provider: &CudaKernelProvider,
        storage: Arc<PublicationStorage>,
        reader: DeviceMemoryView<PublicationLease>,
    ) -> Result<Self, SemanticTransitionError> {
        let plans = Self::plan(&storage)?;
        let mut reservation = provider
            .memory()
            .reserve_bytes(Self::allocation_bytes(&plans)? as u64)
            .map_err(|error| runtime_error("step input reservation", error))?;
        Self::allocate_reserved(provider, storage, reader, plans, &mut reservation)
    }

    fn allocate_reserved(
        provider: &CudaKernelProvider,
        storage: Arc<PublicationStorage>,
        reader: DeviceMemoryView<PublicationLease>,
        plans: Vec<StepInputPlan>,
        reservation: &mut GpuMemoryReservation,
    ) -> Result<Self, SemanticTransitionError> {
        let contract = storage.contract_value;
        if contract.abi != 1
            || contract.model_generation == 0
            || contract.window_capacity != 32
            || reader.len() != 1
        {
            return Err(publication_input_error(
                "fixed step inputs require the original admitted model contract and device reader",
            ));
        }
        let execute = provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_publication_step_inputs",
            )
            .ok_or_else(|| {
                runtime_error(
                    "kernel lookup",
                    "publication step input producer unavailable",
                )
            })?;
        let guard = provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_publication_step_input_guard",
            )
            .ok_or_else(|| {
                runtime_error("kernel lookup", "publication step input guard unavailable")
            })?;
        let mut private = Vec::new();
        let completed_guard = provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_completed_step_input_guard",
            )
            .ok_or_else(|| runtime_error("kernel lookup", "completed input guard unavailable"))?;
        let mut views = [BTreeMap::new(), BTreeMap::new()];
        let mut binding_values = [
            Vec::with_capacity(plans.len()),
            Vec::with_capacity(plans.len()),
        ];
        for input in &plans {
            if matches!(input.role, 1 | 4 | 5 | 18..=25) {
                for bank in 0..2 {
                    let plan = &input.banks[bank];
                    let view = storage.allocations[plan.storage_slot]
                        .view()
                        .slice(plan.span.clone());
                    let backing = if matches!(input.role, 18..=25) {
                        view.allocation_view()
                            .ok_or(SemanticTransitionError::ObservationMismatch)?
                    } else {
                        view.clone()
                    };
                    binding_values[bank].push(PublicationStepInput {
                        role: input.role,
                        index: input.index,
                        destination: *view.device_ptr(),
                        capacity_bytes: view.len() as u64,
                        backing: *backing.device_ptr(),
                        backing_bytes: backing.len() as u64,
                        layout: input.layout,
                    });
                    views[bank].insert((input.role, input.index), view);
                }
            } else {
                private.push(
                    reservation
                        .alloc::<u8>(input.banks[0].span.len())
                        .map_err(|error| runtime_error("step private input allocation", error))?,
                );
                let view = private
                    .last()
                    .expect("retained private input allocation")
                    .view();
                for bank in 0..2 {
                    binding_values[bank].push(PublicationStepInput {
                        role: input.role,
                        index: input.index,
                        destination: *view.device_ptr(),
                        capacity_bytes: view.len() as u64,
                        backing: *view.device_ptr(),
                        backing_bytes: view.len() as u64,
                        layout: if matches!(input.role, 3 | 15..=17 | 44) {
                            SemanticTensorLayout::default()
                        } else {
                            input.layout
                        },
                    });
                    views[bank].insert((input.role, input.index), view.clone());
                }
            }
        }
        let owner = Self {
            header: reservation
                .alloc(1)
                .map_err(|error| runtime_error("step header allocation", error))?,
            source: reservation
                .alloc(32)
                .map_err(|error| runtime_error("step source allocation", error))?,
            ranges: reservation
                .alloc(plans.len())
                .map_err(|error| runtime_error("step range allocation", error))?,
            metadata_digests: reservation
                .alloc(8)
                .map_err(|error| runtime_error("step digest allocation", error))?,
            bindings: [
                reservation
                    .alloc(plans.len())
                    .map_err(|error| runtime_error("step binding allocation", error))?,
                reservation
                    .alloc(plans.len())
                    .map_err(|error| runtime_error("step binding allocation", error))?,
            ],
            storage,
            reader,
            plans,
            views,
            private,
            binding_values,
            execute,
            guard,
            completed_guard,
        };
        owner.validate_output_regions()?;
        Ok(owner)
    }

    fn validate_output_regions(&self) -> Result<(), SemanticTransitionError> {
        let mut output = vec![
            (
                self.header.device_ptr_value(),
                size_of::<PublicationHeader>(),
            ),
            (self.source.device_ptr_value(), 32 * size_of::<SourceSlot>()),
            (
                self.ranges.device_ptr_value(),
                self.ranges.len() * size_of::<PublicationRange>(),
            ),
            (self.metadata_digests.device_ptr_value(), u64::BITS as usize),
            (
                self.bindings[0].device_ptr_value(),
                self.bindings[0].len() * size_of::<PublicationStepInput>(),
            ),
            (
                self.bindings[1].device_ptr_value(),
                self.bindings[1].len() * size_of::<PublicationStepInput>(),
            ),
        ];
        output.extend(
            self.private
                .iter()
                .map(|allocation| (allocation.device_ptr_value(), allocation.len())),
        );
        let mut original = self
            .storage
            .allocations
            .iter()
            .map(|allocation| (allocation.device_ptr_value(), allocation.len()))
            .collect::<Vec<_>>();
        original.extend(
            self.storage
                .banks
                .iter()
                .map(|bank| (bank.device_ptr_value(), size_of::<PublicationBank>())),
        );
        original.extend(self.storage.directories.iter().map(|directory| {
            (
                directory.device_ptr_value(),
                directory.len() * size_of::<PublicationRange>(),
            )
        }));
        original.extend([
            (*self.reader.device_ptr(), size_of::<PublicationLease>()),
            (
                self.storage.control.device_ptr_value(),
                size_of::<PublicationControl>(),
            ),
            (
                self.storage.contract.device_ptr_value(),
                size_of::<PublicationContract>(),
            ),
            (
                self.storage.storage.device_ptr_value(),
                self.storage.storage.len() * size_of::<PublicationStorageEntry>(),
            ),
            (
                self.storage.role_counts.device_ptr_value(),
                self.storage.role_counts.len() * size_of::<PublicationRoleCount>(),
            ),
            (
                self.storage.terminals.device_ptr_value(),
                self.storage.terminals.len() * size_of::<u64>(),
            ),
        ]);
        for (ordinal, &(begin, bytes)) in output.iter().enumerate() {
            if bytes == 0 {
                continue;
            }
            let end = begin
                .checked_add(bytes as u64)
                .filter(|&end| begin != 0 && end > begin)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            for &(other, other_bytes) in original.iter().chain(&output[..ordinal]) {
                let other_end = other
                    .checked_add(other_bytes as u64)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                if begin < other_end && other < end {
                    return Err(publication_input_error(
                        "fixed step outputs overlap original storage or another output",
                    ));
                }
            }
        }
        Ok(())
    }

    // Session installs this owner before uploading fixed pointer/layout metadata.
    // No numerical values or expected digests travel through the host.
    fn initialize(&self, provider: &CudaKernelProvider) -> Result<(), SemanticTransitionError> {
        for bank in 0..2 {
            upload_publication(provider, &self.binding_values[bank], &self.bindings[bank])?;
        }
        Ok(())
    }

    fn enqueue(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
    ) -> Result<(), SemanticTransitionError> {
        let mut recorder = domain.new_strict_recorder();
        recorder.read(&self.reader);
        recorder.read(&self.storage.control);
        recorder.read(&self.storage.storage);
        recorder.read(&self.storage.contract);
        recorder.read(&self.storage.role_counts);
        recorder.read(&self.storage.terminals);
        for bank in &self.storage.banks {
            recorder.read(bank);
        }
        for directory in &self.storage.directories {
            recorder.read(directory);
        }
        for allocation in &self.storage.allocations {
            recorder.read(allocation);
        }
        for bindings in &self.bindings {
            recorder.read(bindings);
        }
        recorder.write(&self.header);
        recorder.write(&self.source);
        recorder.write(&self.ranges);
        recorder.write(&self.metadata_digests);
        for allocation in &self.private {
            recorder.write(allocation);
        }
        let arguments = (
            self.storage.control.device_ptr_value(),
            *self.reader.device_ptr(),
            self.bindings[0].device_ptr_value(),
            self.bindings[1].device_ptr_value(),
            self.bindings[0].len() as u64,
            self.header.device_ptr_value(),
            self.source.device_ptr_value(),
            self.ranges.device_ptr_value(),
            self.metadata_digests.device_ptr_value(),
        );
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: every selectable bank and disjoint output is owned before
            // enqueue. The kernel validates all original seals before writing.
            unsafe {
                self.execute.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    fn verify(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
    ) -> Result<(), SemanticTransitionError> {
        self.verify_basis(domain, poisoned, None, false)
    }

    fn verify_completed(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        custody: Option<&PreparedReplayCustody>,
    ) -> Result<(), SemanticTransitionError> {
        self.verify_basis(domain, poisoned, custody, true)
    }

    fn verify_basis(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        custody: Option<&PreparedReplayCustody>,
        completed: bool,
    ) -> Result<(), SemanticTransitionError> {
        let mut recorder = domain.new_strict_recorder();
        recorder.read(&self.header);
        recorder.read(&self.source);
        recorder.read(&self.ranges);
        recorder.read(&self.reader);
        for bindings in &self.bindings {
            recorder.read(bindings);
        }
        recorder.read(&self.metadata_digests);
        for bank in &self.views {
            for view in bank.values() {
                recorder.read(view);
            }
        }
        for allocation in &self.private {
            recorder.read(allocation);
        }
        let bindings = if let Some(custody) = custody {
            if !custody.owns_inputs(self) {
                return Err(publication_input_error(
                    "retained input guard belongs to another original step",
                ));
            }
            let bindings = custody.input_bindings();
            recorder.read(bindings);
            for input in &self.plans {
                if matches!(input.role, 1 | 4 | 5 | 18..=25) {
                    let view = custody.input_view(input.role, input.index)?.0;
                    recorder.read(&view);
                    if matches!(input.role, 18..=25) {
                        recorder.read(
                            &view
                                .allocation_view()
                                .ok_or(SemanticTransitionError::ObservationMismatch)?,
                        );
                    }
                }
            }
            [bindings, bindings]
        } else {
            [&self.bindings[0], &self.bindings[1]]
        };
        let arguments = (
            *self.reader.device_ptr(),
            self.header.device_ptr_value(),
            self.source.device_ptr_value(),
            bindings[0].device_ptr_value(),
            bindings[1].device_ptr_value(),
            bindings[0].len() as u64,
            self.ranges.device_ptr_value(),
            self.metadata_digests.device_ptr_value(),
        );
        let guard = if completed {
            &self.completed_guard
        } else {
            &self.guard
        };
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: private producer snapshots and original shared aliases are
            // retained. No later bank or digest can replace this original basis.
            unsafe {
                guard.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    fn field_view(
        &self,
        field: PublicationBankField,
    ) -> Result<DeviceMemoryView<u8>, SemanticTransitionError> {
        let (span, _, _) = field.layout();
        // SAFETY: only initialized public Source/scalar fields of the checked
        // padding-free ABI are exposed, never the private header or hash words.
        unsafe {
            match field {
                PublicationBankField::Source => self
                    .source
                    .view()
                    .cast::<u8>()
                    .ok_or(SemanticTransitionError::ObservationMismatch),
                _ => self
                    .header
                    .view()
                    .cast::<u8>()
                    .map(|view| view.slice(span))
                    .ok_or(SemanticTransitionError::ObservationMismatch),
            }
        }
    }

    fn training_coordinates_view(&self) -> Result<DeviceMemoryView<u64>, SemanticTransitionError> {
        let begin = std::mem::offset_of!(PublicationHeader, training_cursor);
        let end = begin
            .checked_add(5 * size_of::<u64>())
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        unsafe {
            self.header
                .view()
                .cast::<u8>()
                .map(|view| view.slice(begin..end))
                .and_then(|view| view.cast::<u64>())
                .ok_or(SemanticTransitionError::ObservationMismatch)
        }
    }

    fn owns_tensor(
        &self,
        tensor: &PreparedSemanticTensor,
    ) -> Result<bool, SemanticTransitionError> {
        let bytes = tensor.source.as_ref().map_or(0, DeviceMemoryView::len);
        for field in [
            PublicationBankField::Source,
            PublicationBankField::PrefixExtent,
            PublicationBankField::RingHead,
            PublicationBankField::Terminal,
        ] {
            let view = self.field_view(field)?;
            let start = *view.device_ptr();
            if !step_input_overlap(tensor.data, bytes, start, view.len())? {
                continue;
            }
            let (_, shape, strides) = field.layout();
            let mut layout = SemanticTensorLayout {
                role: 0,
                index: tensor.layout.index,
                scalar_type: 3,
                element_bytes: 8,
                rank: shape.len() as u64,
                logical_axis: u64::MAX,
                ..SemanticTensorLayout::default()
            };
            for (axis, dimension) in shape.into_iter().enumerate() {
                layout.dimensions[axis] = dimension as u64;
            }
            for (axis, stride) in strides.into_iter().enumerate() {
                layout.strides_bytes[axis] = stride as u64 * 8;
            }
            if tensor.data != start
                || bytes != view.len()
                || tensor.layout != layout
                || (tensor.logical_begin, tensor.logical_end) != (0, 0)
            {
                return Err(publication_input_error("native source and scalar aliases must retain their exact exported type and extent"));
            }
            if !step_input_allocation_matches(tensor, &view) {
                return Err(publication_input_error(
                    "native source and scalar allocation origin does not match its producer",
                ));
            }
            return Ok(true);
        }
        for (pointer, capacity) in [
            (
                self.header.device_ptr_value(),
                size_of::<PublicationHeader>(),
            ),
            (
                self.ranges.device_ptr_value(),
                self.ranges.len() * size_of::<PublicationRange>(),
            ),
            (
                self.bindings[0].device_ptr_value(),
                self.bindings[0].len() * size_of::<PublicationStepInput>(),
            ),
            (
                self.bindings[1].device_ptr_value(),
                self.bindings[1].len() * size_of::<PublicationStepInput>(),
            ),
            (
                self.metadata_digests.device_ptr_value(),
                self.metadata_digests.len() * size_of::<u64>(),
            ),
        ] {
            if step_input_overlap(tensor.data, bytes, pointer, capacity)? {
                return Err(publication_input_error("native private header, range and digest storage cannot become a content operand"));
            }
        }
        // Select by the original typed coordinate before testing overlap: two
        // legitimate model views can share any subset of the same backing.
        if let Some(input) = self
            .plans
            .iter()
            .find(|input| (input.role, input.index) == (tensor.layout.role, tensor.layout.index))
        {
            if (18..=25).contains(&input.role) && bytes == 0 && tensor.native_allocation.is_none() {
                return Err(publication_input_error("empty prepared model inputs require their original native allocation provenance"));
            }
            for bank in 0..2 {
                let view = &self.views[bank][&(input.role, input.index)];
                let range = self.storage.bank_templates[bank]
                    .iter()
                    .find(|range| (range.role, range.index) == (input.role, input.index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                if step_input_alias_matches(
                    input,
                    range,
                    *view.device_ptr(),
                    view.len(),
                    tensor_content_identity(tensor),
                ) && step_input_allocation_matches(tensor, view)
                {
                    return Ok(true);
                }
            }
        }
        for bank in 0..2 {
            for input in &self.plans {
                let view = &self.views[bank][&(input.role, input.index)];
                let start = *view.device_ptr();
                if !(step_input_overlap(tensor.data, bytes, start, view.len())?
                    || input.role == 1 && bytes == 0 && tensor.data == start)
                {
                    continue;
                }
                let range = self.storage.bank_templates[bank]
                    .iter()
                    .find(|range| (range.role, range.index) == (input.role, input.index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                if input.role == 1
                    && step_input_alias_matches(
                        input,
                        range,
                        start,
                        view.len(),
                        tensor_content_identity(tensor),
                    )
                    && step_input_allocation_matches(tensor, view)
                {
                    return Ok(true);
                }
                return Err(publication_input_error("native step aliases must retain their original type, capacity, interval and coordinate"));
            }
        }
        for allocation in &self.private {
            let retained_origin = tensor.native_allocation.as_ref().is_some_and(|origin| {
                allocation
                    .view()
                    .allocation_provenance()
                    .is_some_and(|expected| origin.same_allocation(&expected))
            });
            if retained_origin
                || step_input_overlap(
                    tensor.data,
                    bytes,
                    allocation.device_ptr_value(),
                    allocation.len(),
                )?
            {
                return Err(publication_input_error(
                    "native step backing padding cannot become a separate content operand",
                ));
            }
        }
        Ok(false)
    }

    fn owns_bank_model_tensor(
        &self,
        bank: usize,
        tensor: &PreparedSemanticTensor,
    ) -> Result<bool, SemanticTransitionError> {
        if bank > 1 || !(18..=25).contains(&tensor.layout.role) {
            return Ok(false);
        }
        let Some(input) = self
            .plans
            .iter()
            .find(|input| (input.role, input.index) == (tensor.layout.role, tensor.layout.index))
        else {
            return Ok(false);
        };
        let view = &self.views[bank][&(input.role, input.index)];
        let range = self.storage.bank_templates[bank]
            .iter()
            .find(|range| (range.role, range.index) == (input.role, input.index))
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        Ok(step_input_alias_matches(
            input,
            range,
            *view.device_ptr(),
            view.len(),
            tensor_content_identity(tensor),
        ) && step_input_allocation_matches(tensor, view))
    }
}

fn step_input_allocation_matches(
    tensor: &PreparedSemanticTensor,
    view: &DeviceMemoryView<u8>,
) -> bool {
    match &tensor.native_allocation {
        Some(origin) => view
            .allocation_provenance()
            .is_some_and(|expected| origin.same_allocation(&expected)),
        // An address locates nonempty retained storage, but all independent
        // zero-byte native allocations may have the same null address.
        None => !view.is_empty(),
    }
}

fn step_input_alias_matches(
    input: &StepInputPlan,
    range: &PublicationRange,
    data: u64,
    capacity: usize,
    actual: (SemanticTensorLayout, u64, u64, u64, usize),
) -> bool {
    if actual.3 != data {
        return false;
    }
    let typed_capacity = actual.4 == capacity
        && actual.0 == input.layout
        && (actual.1, actual.2) == (range.logical_begin, range.logical_end);
    // The public raw prefix export is the exact committed byte interval of
    // this same original capacity allocation. It still uses the producer's
    // original raw prefix seal, including the legal empty prefix.
    let raw_prefix = input.role == 1
        && input.index == 0
        && range.role == 1
        && range.index == 0
        && actual.0 == publication_record_layout(range)
        && (actual.1, actual.2) == (0, 0)
        && u64::try_from(actual.4).ok() == Some(range.length_bytes)
        && actual.4 <= capacity;
    typed_capacity || raw_prefix
}

// Numerical producers and their original seals outlive the bank they consumed.
// A step is installed alongside acquisition, before any operation can enqueue.
// Its identity is set only after that actual device acquisition is validated.
struct StepContentStorage {
    identity: Option<SemanticPublishedIdentity>,
    content_witnesses: Arc<()>,
    aliases: Arc<()>,
    consumer_streams: BTreeSet<u64>,
    inputs: Option<Arc<PreparedStepInputs>>,
    // Deleters do not establish completion. Final step retirement joins every
    // recorded consumer before clearing any of these actual output owners.
    feedback: Vec<FeedbackBuffers>,
    content: Vec<TensorContentBuffers>,
    #[cfg_attr(
        not(feature = "semantic-policy"),
        expect(
            dead_code,
            reason = "adjoints are consumed by the semantic-policy VJP path"
        )
    )]
    adjoints: Vec<DeviceMemoryView<u8>>,
    #[cfg(feature = "semantic-policy")]
    policy_vjp_workspaces: Vec<Arc<PolicyVjpWorkspace>>,
    prepared: Option<PreparedStepStorage>,
    #[cfg(feature = "semantic-policy")]
    evaluation: Option<model_evaluation::EvaluationStorage>,
}

impl StepContentStorage {
    fn new() -> Self {
        Self {
            identity: None,
            content_witnesses: Arc::new(()),
            aliases: Arc::new(()),
            consumer_streams: BTreeSet::new(),
            inputs: None,
            feedback: Vec::new(),
            content: Vec::new(),
            adjoints: Vec::new(),
            #[cfg(feature = "semantic-policy")]
            policy_vjp_workspaces: Vec::new(),
            prepared: None,
            #[cfg(feature = "semantic-policy")]
            evaluation: None,
        }
    }
}

/// A fixed future step issued by its Session during cold segment construction.
/// It owns no host publication identity; its actual parent is acquired on device.
#[derive(Clone, Debug)]
pub struct SemanticPreparedStep {
    issuer: Arc<()>,
    scope: Arc<()>,
    token: u64,
}

impl SemanticPreparedStep {
    pub fn same_handle(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.issuer, &other.issuer)
            && Arc::ptr_eq(&self.scope, &other.scope)
            && self.token == other.token
    }
}

/// Immutable CPU custody of one joined original step observation. The issued
/// step contains identity tokens only, not CUDA storage, graphs or readers.
#[cfg(feature = "semantic-policy")]
pub struct SemanticCompletedExecutionObservation {
    original: SemanticPreparedStep,
    requested_transition: SemanticTransitionKind,
    outcome: SemanticPreparedStepOutcome,
    predecessor: Option<SemanticPublishedIdentity>,
    successor: Option<SemanticPublishedIdentity>,
    model_binding: Option<(u64, Identity256, Identity256)>,
    quantities: [u64; 4],
}

#[cfg(feature = "semantic-policy")]
impl SemanticCompletedExecutionObservation {
    pub fn quantities(&self) -> [u64; 4] {
        self.quantities
    }

    pub fn same_execution(&self, other: &Self) -> bool {
        self.original.same_handle(&other.original)
    }

    pub fn belongs_to(&self, session: &SemanticTransitionSession) -> bool {
        Arc::ptr_eq(&self.original.issuer, &session.publication_issuer)
    }

    pub fn predecessor(&self) -> Option<SemanticPublishedIdentity> {
        self.predecessor
    }

    pub fn successor(&self) -> Option<SemanticPublishedIdentity> {
        self.successor
    }

    /// Original checked outcome, retained without its retired device owners.
    pub fn outcome(&self) -> &SemanticPreparedStepOutcome {
        &self.outcome
    }

    pub fn requested_transition(&self) -> SemanticTransitionKind {
        self.requested_transition
    }

    pub fn model_binding(&self) -> Option<(u64, Identity256, Identity256)> {
        self.model_binding
    }
}

/// Lexical native graph construction. The caller owns this outside any Session
/// mutex while invoking original model producers and instantiating the graph.
pub struct SemanticPreparedSegmentCapture {
    builder: crate::cuda_graph::ConditionalCudaGraphSequenceBuilder,
    scope: Arc<()>,
}

impl SemanticPreparedSegmentCapture {
    pub fn add_conditional_if<P, F, E>(
        &mut self,
        stream: &CudaStream,
        preflight: P,
        body: F,
    ) -> Result<u64, crate::cuda_graph::CudaConditionalGraphUnavailable>
    where
        P: FnOnce(u64) -> Result<(), E>,
        E: fmt::Display,
        F: FnOnce(
            &crate::cuda_graph::ConditionalCudaGraphBody,
        ) -> Result<(), crate::cuda_graph::CudaConditionalGraphUnavailable>,
    {
        self.builder.add_conditional_if(stream, preflight, body)
    }

    pub fn instantiate(self) -> Result<SemanticPreparedExecutable, SemanticTransitionError> {
        let graph = self
            .builder
            .instantiate()
            .map_err(|error| runtime_error("bounded segment instantiation", error))?;
        Ok(SemanticPreparedExecutable {
            scope: self.scope,
            graph,
        })
    }
}

/// A graph produced by one authentic Session construction scope. Only the
/// owning Session can take it; the caller retains it on installation failure.
pub struct SemanticPreparedExecutable {
    scope: Arc<()>,
    graph: CapturedCudaGraph,
}

struct PreparedSegmentState {
    issuer: Arc<()>,
    scope: Arc<()>,
    tokens: Vec<u64>,
    transitions: Vec<SemanticTransitionKind>,
    cold_capacity: SemanticSegmentColdCapacity,
    cold_reservation: Option<GpuMemoryReservation>,
    next: usize,
    active: bool,
    finished: bool,
    capturing: bool,
    submitted: bool,
    completed: bool,
}

impl PreparedSegmentState {
    fn new(
        issuer: Arc<()>,
        tokens: Vec<u64>,
        transitions: impl ExactSizeIterator<Item = SemanticTransitionKind> + Clone,
        cold_capacity: SemanticSegmentColdCapacity,
    ) -> Result<Self, SemanticTransitionError> {
        if tokens.is_empty()
            || tokens.contains(&0)
            || tokens.iter().copied().collect::<BTreeSet<_>>().len() != tokens.len()
            || tokens.len() != transitions.len()
            || transitions
                .clone()
                .any(|kind| kind == SemanticTransitionKind::Drain)
        {
            return Err(publication_input_error("a prepared segment requires distinct owned steps and one frozen proposal, recompute, or update mode per step"));
        }
        let mut owned = Vec::new();
        owned
            .try_reserve_exact(transitions.len())
            .map_err(|error| runtime_error("prepared schedule reservation", error))?;
        owned.extend(transitions);
        cold_capacity.external_floor()?;
        Ok(Self {
            issuer,
            scope: Arc::new(()),
            tokens,
            transitions: owned,
            cold_capacity,
            cold_reservation: None,
            next: 0,
            active: false,
            finished: false,
            capturing: false,
            submitted: false,
            completed: false,
        })
    }

    fn handles(&self) -> Result<Vec<SemanticPreparedStep>, SemanticTransitionError> {
        let mut handles = Vec::new();
        handles
            .try_reserve_exact(self.tokens.len())
            .map_err(|error| runtime_error("prepared handle reservation", error))?;
        handles.extend(self.tokens.iter().map(|&token| SemanticPreparedStep {
            issuer: Arc::clone(&self.issuer),
            scope: Arc::clone(&self.scope),
            token,
        }));
        Ok(handles)
    }

    fn check(
        &self,
        step: &SemanticPreparedStep,
        issuer: &Arc<()>,
        recording: bool,
    ) -> Result<(), SemanticTransitionError> {
        self.check_retained(step, issuer)?;
        if self.finished
            || (recording && (!self.active || self.tokens.get(self.next) != Some(&step.token)))
        {
            return Err(publication_input_error(
                "prepared step differs from its owning Session or active construction scope",
            ));
        }
        Ok(())
    }

    fn check_retained(
        &self,
        step: &SemanticPreparedStep,
        issuer: &Arc<()>,
    ) -> Result<(), SemanticTransitionError> {
        if !Arc::ptr_eq(issuer, &self.issuer)
            || !Arc::ptr_eq(&step.issuer, issuer)
            || !Arc::ptr_eq(&step.scope, &self.scope)
            || !self.tokens.contains(&step.token)
        {
            return Err(publication_input_error(
                "retained prepared step differs from its original Session and construction scope",
            ));
        }
        Ok(())
    }

    fn requested_kind(
        &self,
        step: &SemanticPreparedStep,
        issuer: &Arc<()>,
    ) -> Result<SemanticTransitionKind, SemanticTransitionError> {
        self.check_retained(step, issuer)?;
        let index = self
            .tokens
            .iter()
            .position(|&token| token == step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        Ok(self.transitions[index])
    }

    fn enter(
        &mut self,
        step: &SemanticPreparedStep,
        issuer: &Arc<()>,
    ) -> Result<SemanticTransitionKind, SemanticTransitionError> {
        self.check(step, issuer, false)?;
        if self.active || self.tokens.get(self.next) != Some(&step.token) {
            return Err(publication_input_error(
                "prepared steps must record once in their original bounded order",
            ));
        }
        self.active = true;
        Ok(self.transitions[self.next])
    }

    fn leave(
        &mut self,
        step: &SemanticPreparedStep,
        issuer: &Arc<()>,
    ) -> Result<(), SemanticTransitionError> {
        self.check(step, issuer, true)?;
        self.active = false;
        self.next += 1;
        Ok(())
    }

    fn finish(&mut self) -> Result<(), SemanticTransitionError> {
        if self.finished || self.active || self.next != self.tokens.len() {
            return Err(publication_input_error(
                "prepared segment has unrecorded or unfinished steps",
            ));
        }
        self.finished = true;
        Ok(())
    }

    #[cfg(any(test, feature = "semantic-policy"))]
    fn submit(&mut self) -> Result<(), SemanticTransitionError> {
        if !self.finished
            || self.active
            || self.next != self.tokens.len()
            || self.submitted
            || self.completed
        {
            return Err(publication_input_error(
                "prepared segment submission requires one complete unused construction",
            ));
        }
        self.submitted = true;
        Ok(())
    }
}

struct PreparedStepStorage {
    reader: TrackedCudaSlice<PublicationLease>,
    replay_custody: Option<PreparedReplayCustody>,
    branches: [PreparedBranchStorage; 2],
    digests: Option<Arc<TrackedCudaSlice<u64>>>,
    next_digest: usize,
    model_work: Option<PreparedModelWork>,
    admit: CudaFunction,
    kind_gate: CudaFunction,
    kind_bank_gate: CudaFunction,
    active_gate: CudaFunction,
    #[cfg_attr(
        not(feature = "semantic-policy"),
        expect(
            dead_code,
            reason = "drain preparation is captured by the semantic-policy graph"
        )
    )]
    drain_prepare: CudaFunction,
    release: CudaFunction,
    witness: CudaFunction,
    content_guard: CudaFunction,
    inputs_recorded: bool,
    model_content_recorded: u8,
    transition_recorded: u8,
    drain_recorded: bool,
    observed: bool,
    // Original reconciled CPU evidence survives prepared-storage retirement in
    // the issued execution observation; it owns no graph, reader or tensor.
    #[cfg(feature = "semantic-policy")]
    observed_outcome: Option<SemanticPreparedStepOutcome>,
    #[cfg(feature = "semantic-policy")]
    observed_parent: Option<PublicationHeader>,
    #[cfg(feature = "semantic-policy")]
    observed_result: Option<PreparedStepResult>,
    result: TrackedCudaSlice<PreparedStepResult>,
    training_origin: Option<DeviceMemoryView<SemanticTrainingViewOriginRecord>>,
    training_view: Option<SemanticSelectedTrainingView>,
    #[cfg(feature = "semantic-policy")]
    group_vjp_members: [BTreeSet<u64>; 2],
    #[cfg(feature = "semantic-policy")]
    group_edit_members: [BTreeSet<u64>; 2],
    #[cfg(feature = "semantic-policy")]
    group_imported_vjp_members: [BTreeSet<u64>; 2],
    #[cfg(feature = "semantic-policy")]
    group_gradient_members: [BTreeSet<u64>; 2],
    #[cfg(feature = "semantic-policy")]
    group_critic_recorded: u8,
    #[cfg(feature = "semantic-policy")]
    group_update_published: bool,
    result_kernel: CudaFunction,
}

struct PreparedBranchStorage {
    model_update: Option<PreparedModelUpdate>,
    continuation: Option<PreparedContinuation>,
    numerical_block_snapshot: Option<Arc<TrackedCudaSlice<f64>>>,
    #[cfg(feature = "semantic-policy")]
    policy_buffers: Option<PolicyBuffers>,
    #[cfg(feature = "semantic-policy")]
    policy: Option<PolicyStorage>,
    #[cfg(feature = "semantic-policy")]
    support: Option<TrackedCudaSlice<u8>>,
    #[cfg(feature = "semantic-policy")]
    receipts: Option<TrackedCudaSlice<SemanticTransitionReceipt>>,
    #[cfg(feature = "semantic-policy")]
    state: TrackedCudaSlice<DeviceState>,
    #[cfg(feature = "semantic-policy")]
    policy_sources: Vec<PreparedSemanticTensor>,
    #[cfg(feature = "semantic-policy")]
    policy_witness: Option<SemanticTensorContentWitness>,
}

struct PreparedModelUpdate {
    bindings: TrackedCudaSlice<ModelUpdateBinding>,
    evidence: Arc<TrackedCudaSlice<ModelUpdateEvidenceSource>>,
    evidence_owners: Arc<Vec<ModelUpdateEvidenceOwner>>,
    forward_seals: TrackedCudaSlice<ModelForwardSealInput>,
    forward_receipts: TrackedCudaSlice<ModelForwardReceipt>,
    admissibility: TrackedCudaSlice<u8>,
    canary_results: TrackedCudaSlice<SemanticTrainingCanaryResultRecord>,
    refusal: TrackedCudaSlice<SemanticTrainingCanaryRefusalRecord>,
    output: Option<BoundModelUpdate>,
    forward_recorded: u8,
    #[cfg_attr(
        not(feature = "semantic-policy"),
        expect(
            dead_code,
            reason = "update admissibility is copied by the semantic-policy graph"
        )
    )]
    admissibility_copy: CudaFunction,
    forward_receipt: CudaFunction,
    #[cfg_attr(
        not(feature = "semantic-policy"),
        expect(
            dead_code,
            reason = "model updates are copied by the semantic-policy graph"
        )
    )]
    copy: CudaFunction,
}

struct BoundModelUpdate {
    values: Vec<ModelUpdateBinding>,
    forward_seal_values: Vec<ModelForwardSealInput>,
    digest_cells: Vec<Arc<TrackedCudaSlice<u64>>>,
    allocations: Vec<PreparedSemanticTensor>,
    admissibility: PreparedSemanticTensor,
    baseline_logits: PreparedSemanticTensor,
    candidate_logits: PreparedSemanticTensor,
    _slab_backing: PreparedSemanticTensor,
    #[cfg(feature = "semantic-policy")]
    accounted_reserved_bytes: u64,
    #[cfg(feature = "semantic-policy")]
    copy_bytes: u64,
    _witness: SemanticTensorContentWitness,
    _forward_witnesses: [SemanticModelForwardWitness; 2],
}

struct ModelUpdateEvidenceOwner {
    lease: DeviceMemoryView<PublicationLease>,
    parent_header: DeviceMemoryView<PublicationHeader>,
    result: DeviceMemoryView<PreparedStepResult>,
    origin: DeviceMemoryView<SemanticTrainingViewOriginRecord>,
    states: [DeviceMemoryView<DeviceState>; 2],
}

impl PreparedModelUpdate {
    #[cfg(feature = "semantic-policy")]
    fn accounted_allocation_bytes(&self) -> Result<u64, SemanticTransitionError> {
        let mut allocations = Vec::new();
        account_tracked_allocation(&mut allocations, &self.bindings)?;
        account_tracked_allocation(&mut allocations, self.evidence.as_ref())?;
        account_tracked_allocation(&mut allocations, &self.forward_seals)?;
        account_tracked_allocation(&mut allocations, &self.forward_receipts)?;
        account_tracked_allocation(&mut allocations, &self.admissibility)?;
        account_tracked_allocation(&mut allocations, &self.canary_results)?;
        account_tracked_allocation(&mut allocations, &self.refusal)?;
        accounted_tracked_bytes(allocations)
    }

    fn descriptor(&self) -> ModelUpdateContinuationInputs {
        ModelUpdateContinuationInputs {
            bindings: self.bindings.device_ptr_value(),
            binding_count: self.bindings.len() as u64,
            admissibility: self.admissibility.device_ptr_value(),
            refusal: self.refusal.device_ptr_value(),
            canary_results: self.canary_results.device_ptr_value(),
        }
    }

    fn record(&self, recorder: &mut LaunchRecorder) {
        recorder.read(&self.bindings);
        recorder.read(self.evidence.as_ref());
        for evidence in self.evidence_owners.iter() {
            recorder.read(&evidence.lease);
            recorder.read(&evidence.parent_header);
            recorder.read(&evidence.result);
            recorder.read(&evidence.origin);
            recorder.read(&evidence.states[0]);
            recorder.read(&evidence.states[1]);
        }
        recorder.read(&self.forward_seals);
        recorder.read_write(&self.forward_receipts);
        recorder.read_write(&self.admissibility);
        recorder.read_write(&self.refusal);
        recorder.read(&self.canary_results);
        if let Some(output) = &self.output {
            for allocation in &output.allocations {
                if let Some(source) = &allocation.source {
                    recorder.read(source);
                }
            }
            if let Some(source) = &output.admissibility.source {
                recorder.read(source);
            }
            if let Some(source) = &output.baseline_logits.source {
                recorder.read(source);
            }
            if let Some(source) = &output.candidate_logits.source {
                recorder.read(source);
            }
            for cells in &output.digest_cells {
                recorder.read(cells.as_ref());
            }
        }
    }

    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the update gate joins publication, training, task and original model-work owners"
    )]
    fn enqueue_copy(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        storage: &PublicationStorage,
        reader: &TrackedCudaSlice<PublicationLease>,
        training_view: &SemanticSelectedTrainingView,
        task: &TrackedCudaSlice<u64>,
        model_work: &PreparedModelWork,
    ) -> Result<(), SemanticTransitionError> {
        let output = self.output.as_ref().ok_or_else(|| {
            publication_input_error("prepared update has no original model output binding")
        })?;
        let allocation_count = u32::try_from(output.values.len())
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        if allocation_count == 0 || allocation_count > 65_535 {
            return Err(publication_input_error(
                "prepared update model allocation roster exceeds the CUDA launch geometry",
            ));
        }
        let maximum_bytes = output
            .values
            .iter()
            .map(|binding| binding.bytes)
            .max()
            .unwrap_or(0);
        let blocks = maximum_bytes.div_ceil(256).clamp(1, 65_535) as u32;
        let mut recorder = domain.new_strict_recorder();
        storage.record(&mut recorder);
        recorder.read(reader);
        self.record(&mut recorder);
        model_work.record_reads(&mut recorder);
        recorder.read(task);
        let selection = training_view.selection();
        let roster_rows = training_view.roster_rows();
        let objective = training_view.objective();
        let canaries = training_view.canaries();
        let protected_members = training_view.protected_members();
        let retention_labels = training_view.retention_labels();
        let kinds = training_view.kinds();
        recorder.read(&selection);
        recorder.read(&roster_rows);
        recorder.read(&objective);
        recorder.read(&canaries);
        recorder.read(&protected_members);
        recorder.read(&retention_labels);
        recorder.read(&kinds);
        recorder.write(&self.canary_results);
        recorder.write(&self.admissibility);
        recorder.write(&self.refusal);
        let admissibility_source = output.admissibility.data;
        let canary_results = self.canary_results.device_ptr_value();
        let admissibility_destination = self.admissibility.device_ptr_value();
        let refusal_destination = self.refusal.device_ptr_value();
        let training_view_bytes = training_view.accounted_allocation_bytes()?;
        let model_work_bytes = model_work.accounted_allocation_bytes()?;
        let update_bytes = self.accounted_allocation_bytes()?;
        let task_bytes = task
            .view()
            .allocation_provenance()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .allocation_bytes();
        let accounted_reserved_bytes = output
            .accounted_reserved_bytes
            .checked_add(storage.accounted_allocation_bytes()?)
            .and_then(|bytes| bytes.checked_add(training_view_bytes))
            .and_then(|bytes| bytes.checked_add(task_bytes))
            .and_then(|bytes| bytes.checked_add(model_work_bytes))
            .and_then(|bytes| bytes.checked_add(update_bytes))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let logits = output.baseline_logits.layout;
        let canary_inputs = ModelUpdateCanaryInputs {
            control: storage.control.device_ptr_value(),
            lease: reader.device_ptr_value(),
            selection: *selection.device_ptr(),
            roster_rows: *roster_rows.device_ptr(),
            objective: *objective.device_ptr(),
            canaries: *canaries.device_ptr(),
            canary_count: canaries.len() as u64,
            protected_members: *protected_members.device_ptr(),
            protected_member_count: protected_members.len() as u64,
            task: task.device_ptr_value(),
            task_words: task.len() as u64,
            evidence: self.evidence.device_ptr_value(),
            evidence_count: self.evidence.len() as u64,
            forward_receipts: self.forward_receipts.device_ptr_value(),
            candidate_seal_count: self.forward_seals.len() as u64,
            retention_labels: *retention_labels.device_ptr(),
            kinds: *kinds.device_ptr(),
            baseline_logits: output.baseline_logits.data,
            candidate_logits: output.candidate_logits.data,
            scalar_type: logits.scalar_type,
            row_count: logits.dimensions[0],
            capacity: logits.dimensions[1],
            vocabulary: logits.dimensions[2],
            row_stride_bytes: logits.strides_bytes[0],
            position_stride_bytes: logits.strides_bytes[1],
            vocabulary_stride_bytes: logits.strides_bytes[2],
            model_work: model_work.descriptor(),
            accounted_reserved_bytes,
            copy_bytes: output.copy_bytes,
            admissibility_source,
            results: canary_results,
            admissibility_destination,
            refusal_destination,
        };
        let arguments = (
            storage.control.device_ptr_value(),
            reader.device_ptr_value(),
        );
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: the producer gate was checked by the same captured
            // content witness as the complete update backing. The native byte
            // is the stable predicate consumed by both copy and publication.
            unsafe {
                self.admissibility_copy.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (canary_inputs,),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))?;
            // SAFETY: the continuation kernel validated this immutable binding
            // roster first. Each CUDA grid row copies one disjoint allocation
            // into the inactive neural bank retained by PublicationStorage.
            unsafe {
                self.copy.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (blocks, allocation_count, 1),
                        block_dim: (256, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }
}

struct PreparedModelWork {
    recording: ModelWorkRecording,
    device: TrackedCudaSlice<ModelWorkEvent>,
    actual: TrackedCudaSlice<u64>,
    reset: CudaFunction,
    invocation: CudaFunction,
    capture_bank: Option<usize>,
    replay_cursor: usize,
    evaluation_recording: bool,
}

const PREPARED_TRANSITION_BANKS: u8 = 0b11;

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelWorkInput {
    events: u64,
    count: u64,
    bound: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct ModelUpdateCanaryInputs {
    control: u64,
    lease: u64,
    selection: u64,
    roster_rows: u64,
    objective: u64,
    canaries: u64,
    canary_count: u64,
    protected_members: u64,
    protected_member_count: u64,
    task: u64,
    task_words: u64,
    evidence: u64,
    evidence_count: u64,
    forward_receipts: u64,
    candidate_seal_count: u64,
    retention_labels: u64,
    kinds: u64,
    baseline_logits: u64,
    candidate_logits: u64,
    scalar_type: u64,
    row_count: u64,
    capacity: u64,
    vocabulary: u64,
    row_stride_bytes: u64,
    position_stride_bytes: u64,
    vocabulary_stride_bytes: u64,
    model_work: ModelWorkInput,
    accounted_reserved_bytes: u64,
    copy_bytes: u64,
    admissibility_source: u64,
    results: u64,
    admissibility_destination: u64,
    refusal_destination: u64,
}

const _: () = assert!(size_of::<ModelUpdateCanaryInputs>() == 280);

struct ModelForwardReceiptInputsParam(ModelForwardReceiptInputs);

impl crate::cuda_compat::KernelParamStorage for ModelForwardReceiptInputsParam {
    fn as_kernel_param(&self) -> *mut std::ffi::c_void {
        (&self.0 as *const ModelForwardReceiptInputs)
            .cast_mut()
            .cast()
    }
}

impl crate::cuda_compat::IntoKernelParamStorage for ModelForwardReceiptInputs {
    type Storage = ModelForwardReceiptInputsParam;

    fn into_kernel_param_storage(self) -> Self::Storage {
        ModelForwardReceiptInputsParam(self)
    }
}

struct ModelUpdateCanaryInputsParam(ModelUpdateCanaryInputs);

impl crate::cuda_compat::KernelParamStorage for ModelUpdateCanaryInputsParam {
    fn as_kernel_param(&self) -> *mut std::ffi::c_void {
        (&self.0 as *const ModelUpdateCanaryInputs)
            .cast_mut()
            .cast()
    }
}

impl crate::cuda_compat::IntoKernelParamStorage for ModelUpdateCanaryInputs {
    type Storage = ModelUpdateCanaryInputsParam;

    fn into_kernel_param_storage(self) -> Self::Storage {
        ModelUpdateCanaryInputsParam(self)
    }
}

impl PreparedModelWork {
    fn allocate(
        provider: &Arc<CudaKernelProvider>,
        reservation: &mut crate::memory::GpuMemoryReservation,
        capacity: usize,
    ) -> Result<Self, SemanticTransitionError> {
        let recording = ModelWorkRecording::new(capacity).map_err(publication_input_error)?;
        let reset = provider
            .device()
            .inner()
            .get_func("xlog_semantic_transition", "semantic_model_work_reset")
            .ok_or_else(|| runtime_error("kernel lookup", "model work reset unavailable"))?;
        let invocation = provider
            .device()
            .inner()
            .get_func("xlog_semantic_transition", "semantic_model_invocation")
            .ok_or_else(|| runtime_error("kernel lookup", "model invocation marker unavailable"))?;
        Ok(Self {
            recording,
            device: reservation
                .alloc(capacity)
                .map_err(|error| runtime_error("original model work allocation", error))?,
            actual: reservation
                .alloc(
                    capacity
                        .checked_mul(3)
                        .ok_or(SemanticTransitionError::GenerationExhausted)?,
                )
                .map_err(|error| runtime_error("original device work allocation", error))?,
            reset,
            invocation,
            capture_bank: None,
            replay_cursor: 0,
            evaluation_recording: false,
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn accounted_allocation_bytes(&self) -> Result<u64, SemanticTransitionError> {
        let mut allocations = Vec::new();
        account_tracked_allocation(&mut allocations, &self.device)?;
        account_tracked_allocation(&mut allocations, &self.actual)?;
        accounted_tracked_bytes(allocations)
    }

    #[cfg(feature = "semantic-policy")]
    fn record_reads(&self, recorder: &mut LaunchRecorder) {
        recorder.read(&self.device);
        recorder.read(&self.actual);
    }

    #[cfg(feature = "semantic-policy")]
    fn begin_capture(&mut self, bank: usize, recorded: u8) -> Result<(), &'static str> {
        if bank > 1 || self.capture_bank.is_some() || self.evaluation_recording {
            return Err("model work capture requires one inactive bank recording");
        }
        if (bank == 0 && (recorded != 0 || self.recording.frozen_bound().is_some()))
            || (bank == 1 && (recorded != 1 || self.recording.frozen_bound().is_none()))
        {
            return Err("model work banks must record in zero then one order");
        }
        self.capture_bank = Some(bank);
        self.replay_cursor = 0;
        Ok(())
    }

    fn next_slot(&self) -> Result<usize, &'static str> {
        match self.capture_bank {
            Some(0) => Ok(self.recording.events().len()),
            Some(1) => Ok(self.replay_cursor),
            None if self.evaluation_recording => Ok(self.recording.events().len()),
            _ => Err("model work event requires an active prepared bank capture"),
        }
    }

    fn record_event(&mut self, event: ModelWorkEvent) -> Result<usize, &'static str> {
        let slot = self.next_slot()?;
        match self.capture_bank {
            Some(0) => self.recording.push(event)?,
            None if self.evaluation_recording => self.recording.push(event)?,
            Some(1) => {
                if self.recording.events().get(slot) != Some(&event) {
                    return Err("second model branch differs from original work geometry");
                }
                self.replay_cursor += 1;
            }
            _ => return Err("model work event requires an active prepared bank capture"),
        }
        Ok(slot)
    }

    #[cfg(feature = "semantic-policy")]
    fn finish_capture(&mut self, bank: usize) -> Result<(), &'static str> {
        if self.capture_bank != Some(bank) {
            return Err("prepared transition differs from its active model work bank");
        }
        if bank == 0 {
            self.recording.require_model_invocations()?;
            self.recording.freeze()?;
        } else if self.replay_cursor != self.recording.events().len() {
            return Err("second model branch omitted original work occurrences");
        }
        self.capture_bank = None;
        self.replay_cursor = 0;
        Ok(())
    }

    fn reset_slots(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        first: usize,
        count: usize,
    ) -> Result<(), SemanticTransitionError> {
        let end = first
            .checked_add(count)
            .filter(|end| *end <= self.actual.len() / 3)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let mut recorder = domain.new_strict_recorder();
        recorder.write(&self.actual);
        let arguments = (
            self.actual.device_ptr_value() + (first * 3 * size_of::<u64>()) as u64,
            ((end - first) * 3) as u64,
        );
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: the checked range belongs to this original step's cold
            // allocation. Reset and producer kernels share the capture stream.
            unsafe {
                self.reset.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (32, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    fn record_invocation(
        &mut self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
    ) -> Result<(), SemanticTransitionError> {
        let slot = self.next_slot().map_err(publication_input_error)?;
        if slot >= self.actual.len() / 3 {
            return Err(publication_input_error(
                "model invocation exceeds its original cold event capacity",
            ));
        }
        let actual = self
            .actual
            .device_ptr_value()
            .checked_add((slot * 3 * size_of::<u64>()) as u64)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let event = ModelWorkEvent::invocation(actual).map_err(publication_input_error)?;
        self.record_event(event).map_err(publication_input_error)?;
        self.reset_slots(domain, poisoned, slot, 1)?;
        let mut recorder = domain.new_strict_recorder();
        recorder.write(&self.actual);
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: this scalar slot is retained by the original invocation;
            // reset, marker and model execution share its actual capture stream.
            unsafe {
                self.invocation.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (actual,),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn completed_model_calls(
        &self,
        actual: &[u64],
        executed: bool,
    ) -> Result<u64, SemanticTransitionError> {
        if actual.len() != self.actual.len() || self.recording.frozen_bound().is_none() {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let mut calls = 0u64;
        let mut original_markers = 0u64;
        for (slot, event) in self.recording.events().iter().enumerate() {
            if event.kind != ModelWorkKind::ModelInvocation as u64 {
                continue;
            }
            original_markers = original_markers
                .checked_add(1)
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            let value = &actual[slot * 3..slot * 3 + 3];
            match value {
                [0, 0, 0] if !executed => (),
                [1, 0, 1] => {
                    calls = calls
                        .checked_add(1)
                        .ok_or(SemanticTransitionError::GenerationExhausted)?;
                }
                _ => return Err(SemanticTransitionError::ObservationMismatch),
            }
        }
        // Scratch is exported to the model and may retain writable aliases.
        // A complete original receipt certifies consumption of every frozen
        // event; an erased marker cannot turn that execution into zero calls.
        if (executed && (original_markers == 0 || calls != original_markers))
            || (!executed && calls != 0)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(calls)
    }

    fn descriptor(&self) -> ModelWorkInput {
        ModelWorkInput {
            events: self.device.device_ptr_value(),
            count: self.recording.events().len() as u64,
            bound: self
                .recording
                .frozen_bound()
                .expect("original work frozen before enqueue"),
        }
    }
}

#[repr(C)]
#[derive(Clone, Copy, Default, PartialEq, Eq)]
struct PreparedStepResult {
    abi: u64,
    word: u64,
    refusal: u64,
    header: PublicationHeader,
    advanced: u64,
    attempt: AttemptReceipt,
}

#[derive(Clone, Copy)]
#[cfg(feature = "semantic-policy")]
struct PreparedTransitionEvidence {
    transition: SemanticTransitionKind,
    canary_refusal: Option<SemanticTrainingCanaryRefusalRecord>,
}

// SAFETY: the C ABI contains initialized padding-free U64 fields and the
// already verified padding-free publication header representation.
unsafe impl DeviceRepr for PreparedStepResult {}

/// Private device content witness for the exact tensors of one retained parent.
/// Transient witnesses prove stability after capture; model witnesses compare
/// against the originally sealed model baseline. Neither proves computation.
/// The trusted model owner binds the witness to its actual original execution.
/// No digest, device pointer, status, or writable witness storage is exported.
#[derive(Clone)]
pub struct SemanticTensorContentWitness {
    issuer: Arc<()>,
    reader_token: u64,
    index: usize,
    _witness: Arc<()>,
}

/// Opaque proof that the native receipt node for one exact logits occurrence
/// was inserted while its model producer's prepared bank capture was active.
#[derive(Clone)]
pub struct SemanticModelForwardWitness {
    issuer: Arc<()>,
    reader_token: u64,
    bank: usize,
    role: usize,
    content: SemanticTensorContentWitness,
}

struct TensorContentBuffers {
    tensors: Vec<PreparedSemanticTensor>,
    seals: TensorContentSeals,
    // A verification may hand off additional managed aliases. Keep them even
    // after enqueue failure; final step release joins consumer completion.
    verification_inputs: Vec<PreparedSemanticTensor>,
}

enum TensorContentSeals {
    Captured(Vec<CapturedTensorDigest>),
    // Original device seals and contract bytes, not a later bank directory or
    // a replacement baseline computed from the live numerical producer.
    Model(ModelContentSeals),
}

struct ModelContentSeals {
    ranges: TrackedCudaSlice<PublicationRange>,
    contract: TrackedCudaSlice<u8>,
    guard: CudaFunction,
    prepared: Option<PreparedModelContentSeals>,
}

struct PreparedModelContentSeals {
    bank: usize,
    #[cfg(feature = "semantic-policy")]
    storage: Arc<PublicationStorage>,
    #[cfg(feature = "semantic-policy")]
    reader: DeviceMemoryView<PublicationLease>,
    roster: TrackedCudaSlice<u64>,
    #[cfg(feature = "semantic-policy")]
    execute: CudaFunction,
}

struct ModelContentCopyPlan {
    directory_offsets: Vec<usize>,
    contract_storage_slot: usize,
    contract_span: std::ops::Range<usize>,
}

fn model_content_copy_plan(
    directory: &[PublicationRange],
    tensor_ranges: &[usize],
    allocation_bytes: &[usize],
) -> Result<ModelContentCopyPlan, SemanticTransitionError> {
    let mut contracts = directory
        .iter()
        .enumerate()
        .filter(|(_, range)| range.role == 44);
    let (contract_index, contract) = contracts
        .next()
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    let mut seen = BTreeSet::new();
    if contracts.next().is_some()
        || contract.index != 0
        || contract.generation != 1
        || contract.length_bytes == 0
        || tensor_ranges.is_empty()
        || tensor_ranges.iter().any(|&index| {
            !seen.insert(index)
                || directory
                    .get(index)
                    .is_none_or(|range| !matches!(range.role, 18..=20))
        })
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let contract_storage_slot = usize::try_from(contract.storage_slot)
        .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
    let allocation = *allocation_bytes
        .get(contract_storage_slot)
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    let begin = usize::try_from(contract.offset_bytes)
        .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
    let bytes = usize::try_from(contract.length_bytes)
        .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
    let end = begin
        .checked_add(bytes)
        .filter(|&end| end <= allocation)
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    let directory_offsets = tensor_ranges
        .iter()
        .copied()
        .chain(std::iter::once(contract_index))
        .map(|index| {
            index
                .checked_mul(size_of::<PublicationRange>())
                .ok_or(SemanticTransitionError::ObservationMismatch)
        })
        .collect::<Result<Vec<_>, _>>()?;
    directory_offsets
        .len()
        .checked_mul(size_of::<PublicationRange>())
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    Ok(ModelContentCopyPlan {
        directory_offsets,
        contract_storage_slot,
        contract_span: begin..end,
    })
}

impl ModelContentSeals {
    fn allocate(
        provider: &CudaKernelProvider,
        plan: &ModelContentCopyPlan,
    ) -> Result<Self, SemanticTransitionError> {
        Self::with_allocations(
            provider,
            allocate_publication(provider, plan.directory_offsets.len())?,
            allocate_publication(provider, plan.contract_span.len())?,
        )
    }

    fn allocate_reserved(
        provider: &CudaKernelProvider,
        plan: &ModelContentCopyPlan,
        reservation: &mut GpuMemoryReservation,
    ) -> Result<Self, SemanticTransitionError> {
        Self::with_allocations(
            provider,
            reservation
                .alloc(plan.directory_offsets.len())
                .map_err(|error| runtime_error("prepared model seal range allocation", error))?,
            reservation
                .alloc(plan.contract_span.len())
                .map_err(|error| runtime_error("prepared model contract allocation", error))?,
        )
    }

    fn with_allocations(
        provider: &CudaKernelProvider,
        ranges: TrackedCudaSlice<PublicationRange>,
        contract: TrackedCudaSlice<u8>,
    ) -> Result<Self, SemanticTransitionError> {
        let guard = provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_retained_model_contract_guard",
            )
            .ok_or_else(|| {
                runtime_error("kernel lookup", "retained model contract guard unavailable")
            })?;
        Ok(Self {
            ranges,
            contract,
            guard,
            prepared: None,
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn snapshot_prepared(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
    ) -> Result<(), SemanticTransitionError> {
        let source = self
            .prepared
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let mut recorder = domain.new_strict_recorder();
        source.storage.record(&mut recorder);
        recorder.read(&source.reader);
        recorder.read(&source.roster);
        recorder.write(&self.ranges);
        recorder.write(&self.contract);
        let arguments = (
            source.storage.control.device_ptr_value(),
            *source.reader.device_ptr(),
            source.roster.device_ptr_value(),
            (source.roster.len() / 2) as u64,
            self.ranges.device_ptr_value(),
            self.contract.device_ptr_value(),
            self.contract.len() as u64,
        );
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: fixed roster and output capacities are cold-owned; the
            // kernel selects and validates the actual device lease and copies
            // original model seals and contract bytes without resealing them.
            unsafe {
                source.execute.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    fn snapshot(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        directory: &TrackedCudaSlice<PublicationRange>,
        source: &TrackedCudaSlice<u8>,
        plan: &ModelContentCopyPlan,
    ) -> Result<(), SemanticTransitionError> {
        let row_bytes = size_of::<PublicationRange>();
        let directory_bytes = directory
            .len()
            .checked_mul(row_bytes)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if self.ranges.len() != plan.directory_offsets.len()
            || self.contract.len() != plan.contract_span.len()
            || plan.contract_span.end > source.len()
            || plan.directory_offsets.iter().any(|&offset| {
                offset
                    .checked_add(row_bytes)
                    .is_none_or(|end| end > directory_bytes)
            })
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let mut recorder = domain.new_strict_recorder();
        recorder.read(directory);
        recorder.read(source);
        recorder.write(&self.ranges);
        recorder.write(&self.contract);
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: every complete original row and the raw contract interval
            // are bounded above by their actual tracked allocations. Private
            // destinations are retained by Session before this first enqueue.
            unsafe {
                for (index, &offset) in plan.directory_offsets.iter().enumerate() {
                    sys::cuMemcpyDtoDAsync_v2(
                        self.ranges.device_ptr_value() + (index * row_bytes) as u64,
                        directory.device_ptr_value() + offset as u64,
                        row_bytes,
                        enqueue.stream().cu_stream(),
                    )
                    .result()
                    .map_err(|e| XlogError::Kernel(format!("original model seal snapshot: {e}")))?;
                }
                sys::cuMemcpyDtoDAsync_v2(
                    self.contract.device_ptr_value(),
                    source.device_ptr_value() + plan.contract_span.start as u64,
                    self.contract.len(),
                    enqueue.stream().cu_stream(),
                )
                .result()
                .map_err(|e| XlogError::Kernel(format!("original model contract snapshot: {e}")))?;
            }
            Ok::<(), XlogError>(())
        })
    }

    fn verify_contract(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
    ) -> Result<(), SemanticTransitionError> {
        let mut recorder = domain.new_strict_recorder();
        recorder.read(&self.ranges);
        recorder.read(&self.contract);
        let arguments = (
            self.contract.device_ptr_value(),
            self.contract.len() as u64,
            self.ranges.device_ptr_value()
                + ((self.ranges.len() - 1) * size_of::<PublicationRange>()) as u64,
        );
        let execute = self.guard.clone();
        enqueue_recorded(domain, poisoned, recorder, |enqueue| {
            // SAFETY: the last retained row is the original nonempty model
            // contract range; payload and expected seal remain private device
            // copies. No current directory or replacement model digest is read.
            unsafe {
                execute.launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|e| XlogError::Kernel(e.to_string()))
        })
    }
}

enum CapturedTensorDigest {
    Tensor {
        cells: Arc<TrackedCudaSlice<u64>>,
        offset: usize,
        // Native outputs are sealed by their producer before export.
        producer_sealed: bool,
    },
    // Range inputs retain the producer's raw/typed seals. Source and scalar
    // views retain the producer's private complete metadata snapshot.
    Publication(Arc<PreparedStepInputs>),
}

fn captured_tensor_digest_pointer(
    digests: &[CapturedTensorDigest],
    index: usize,
) -> Result<(u64, Arc<TrackedCudaSlice<u64>>), SemanticTransitionError> {
    let CapturedTensorDigest::Tensor { cells, offset, .. } = digests
        .get(index)
        .ok_or(SemanticTransitionError::ObservationMismatch)?
    else {
        return Err(publication_input_error(
            "model forward receipt requires an original transient tensor seal",
        ));
    };
    if offset.checked_add(4).is_none_or(|end| end > cells.len()) {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    Ok((
        cells.device_ptr_value() + (*offset * size_of::<u64>()) as u64,
        Arc::clone(cells),
    ))
}

fn tensor_content_identity(
    tensor: &PreparedSemanticTensor,
) -> (SemanticTensorLayout, u64, u64, u64, usize) {
    (
        tensor.layout,
        tensor.logical_begin,
        tensor.logical_end,
        tensor.data,
        tensor.source.as_ref().map_or(0, DeviceMemoryView::len),
    )
}

#[cfg(feature = "semantic-policy")]
fn cuda_backing_allocation(
    pointer: u64,
    required_bytes: usize,
) -> Result<(u64, u64), SemanticTransitionError> {
    if pointer == 0 || required_bytes == 0 {
        return Err(publication_input_error(
            "accounted update tensor requires a nonempty CUDA allocation",
        ));
    }
    let mut base = 0;
    let mut bytes = 0usize;
    // SAFETY: the prepared tensor was already validated as a live CUDA pointer
    // on this session's current context. This query neither reads nor mutates it.
    let result = unsafe { sys::cuMemGetAddressRange_v2(&mut base, &mut bytes, pointer) };
    if result != sys::cudaError_enum::CUDA_SUCCESS {
        return Err(runtime_error(
            "update backing-allocation query",
            format!("cuMemGetAddressRange_v2 failed with {result:?}"),
        ));
    }
    let bytes = u64::try_from(bytes).map_err(|_| SemanticTransitionError::GenerationExhausted)?;
    let required =
        u64::try_from(required_bytes).map_err(|_| SemanticTransitionError::GenerationExhausted)?;
    if pointer < base
        || pointer
            .checked_add(required)
            .is_none_or(|end| end > base.saturating_add(bytes))
    {
        return Err(publication_input_error(
            "update tensor span exceeds its actual CUDA backing allocation",
        ));
    }
    Ok((base, bytes))
}

#[cfg(feature = "semantic-policy")]
fn accounted_tensor_allocations(
    tensors: &[&PreparedSemanticTensor],
    slab: &PreparedSemanticTensor,
) -> Result<u64, SemanticTransitionError> {
    let slab_bytes = tensor_layout_bytes(&slab.layout)?;
    let slab_end = slab
        .data
        .checked_add(slab_bytes as u64)
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let (slab_base, slab_allocation_bytes) = cuda_backing_allocation(slab.data, slab_bytes)?;
    for tensor in tensors {
        let bytes = tensor_layout_bytes(&tensor.layout)?;
        if bytes == 0 {
            continue;
        }
        let (base, allocation_bytes) = cuda_backing_allocation(tensor.data, bytes)?;
        if tensor.data < slab.data
            || tensor
                .data
                .checked_add(bytes as u64)
                .is_none_or(|end| end > slab_end)
            || base != slab_base
            || allocation_bytes != slab_allocation_bytes
        {
            return Err(publication_input_error(
                "update output or logits differ from the original slab backing allocation",
            ));
        }
    }
    Ok(slab_allocation_bytes)
}

fn same_tensor_content_owner(
    expected: &PreparedSemanticTensor,
    actual: &PreparedSemanticTensor,
) -> bool {
    tensor_content_identity(expected) == tensor_content_identity(actual)
        && match (&expected.native_allocation, &actual.native_allocation) {
            (Some(expected), Some(actual)) => expected.same_allocation(actual),
            (None, None) => true,
            _ => false,
        }
}

impl StepContentStorage {
    fn feedback_origin_digest(
        &self,
        tensor: &PreparedSemanticTensor,
    ) -> Result<Option<CapturedTensorDigest>, SemanticTransitionError> {
        let bytes = tensor.source.as_ref().map_or(0, DeviceMemoryView::len) as u64;
        let end = tensor
            .data
            .checked_add(bytes)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        for feedback in &self.feedback {
            for (index, original) in feedback.content.tensors.iter().enumerate() {
                let source = original
                    .source
                    .as_ref()
                    .expect("native feedback output owner");
                let original_end = original
                    .data
                    .checked_add(source.len() as u64)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                if bytes == 0 || tensor.data >= original_end || original.data >= end {
                    continue;
                }
                if tensor_content_identity(tensor) != tensor_content_identity(original) {
                    return Err(publication_input_error("native feedback aliases must retain their original type, shape, interval and roster coordinate"));
                }
                let TensorContentSeals::Captured(digests) = &feedback.content.seals else {
                    return Err(SemanticTransitionError::ObservationMismatch);
                };
                let CapturedTensorDigest::Tensor { cells, offset, .. } = &digests[index] else {
                    return Err(SemanticTransitionError::ObservationMismatch);
                };
                return Ok(Some(CapturedTensorDigest::Tensor {
                    cells: Arc::clone(cells),
                    offset: *offset,
                    producer_sealed: true,
                }));
            }
        }
        Ok(None)
    }
}

impl TensorContentBuffers {
    fn enqueue(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        execute: &CudaFunction,
        verify: bool,
    ) -> Result<(), SemanticTransitionError> {
        self.enqueue_with_custody(domain, poisoned, execute, verify, None, false)
    }

    fn enqueue_with_custody(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        execute: &CudaFunction,
        verify: bool,
        custody: Option<&PreparedReplayCustody>,
        completed: bool,
    ) -> Result<(), SemanticTransitionError> {
        if let TensorContentSeals::Model(model) = &self.seals {
            if !verify || model.ranges.len() != self.tensors.len() + 1 {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            model.verify_contract(domain, poisoned)?;
        }
        for (ordinal, tensor) in self.tensors.iter().enumerate() {
            if let TensorContentSeals::Captured(digests) = &self.seals {
                if let CapturedTensorDigest::Publication(inputs) = &digests[ordinal] {
                    if !digests[..ordinal].iter().any(|digest| matches!(digest,
                        CapturedTensorDigest::Publication(previous) if Arc::ptr_eq(inputs, previous))) {
                        if completed {
                            inputs.verify_completed(domain, poisoned, custody)?;
                        } else {
                            inputs.verify(domain, poisoned)?;
                        }
                    }
                    // The full-capacity alias may have a shorter original
                    // logical interval. Its original device range is the basis.
                    continue;
                }
            }
            // Keep the caller's original tensor owners in `self.tensors` for
            // every ownership check. Only completed prepared model verification
            // reads the pre-mutation native backing under its original seal.
            let retained;
            let retained_view = match (&self.seals, custody) {
                (TensorContentSeals::Model(model), Some(custody)) => {
                    let bank = model
                        .prepared
                        .as_ref()
                        .ok_or(SemanticTransitionError::ObservationMismatch)?
                        .bank;
                    custody.model_content_view(tensor, bank)?
                }
                _ => None,
            };
            let tensor = if let Some((view, layout)) = retained_view {
                if layout != tensor.layout {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                retained = PreparedSemanticTensor {
                    layout,
                    data: *view.device_ptr(),
                    native_allocation: view.allocation_provenance(),
                    source: Some(view),
                    ..tensor.clone()
                };
                &retained
            } else {
                tensor
            };
            let (pointer, bytes) = tensor
                .source
                .as_ref()
                .map_or((0, 0), |source| (*source.device_ptr(), source.len()));
            let range = tensor_content_range(
                &tensor.layout,
                tensor.logical_begin,
                tensor.logical_end,
                bytes,
            )?;
            let mut recorder = domain.new_strict_recorder();
            if let Some(source) = &tensor.source {
                recorder.read(source);
            }
            let (expected, verify) = match &self.seals {
                TensorContentSeals::Captured(digests) => {
                    let CapturedTensorDigest::Tensor {
                        cells,
                        offset,
                        producer_sealed,
                    } = &digests[ordinal]
                    else {
                        return Err(SemanticTransitionError::ObservationMismatch);
                    };
                    let verify = verify || *producer_sealed;
                    if verify {
                        recorder.read(cells.as_ref());
                    } else {
                        recorder.write(cells.as_ref());
                    }
                    if offset.checked_add(4).is_none_or(|end| end > cells.len()) {
                        return Err(SemanticTransitionError::ObservationMismatch);
                    }
                    (
                        cells.device_ptr_value() + (*offset * size_of::<u64>()) as u64,
                        verify,
                    )
                }
                TensorContentSeals::Model(model) => {
                    recorder.read(&model.ranges);
                    (
                        model.ranges.device_ptr_value()
                            + (ordinal * size_of::<PublicationRange>()
                                + std::mem::offset_of!(PublicationRange, digest))
                                as u64,
                        true,
                    )
                }
            };
            let arguments = (
                pointer,
                bytes as u64,
                range,
                tensor.layout,
                expected,
                u64::from(verify),
            );
            let execute = execute.clone();
            enqueue_recorded(domain, poisoned, recorder, |enqueue| {
                // SAFETY: the original managed source and exact layout retain
                // their allocation; all four private digest cells or the
                // original copied publication rows are retained and recorded.
                unsafe {
                    execute.launch_in(
                        enqueue,
                        LaunchConfig {
                            grid_dim: (1, 1, 1),
                            block_dim: (1, 1, 1),
                            shared_mem_bytes: 0,
                        },
                        arguments,
                    )
                }
                .map_err(|e| XlogError::Kernel(e.to_string()))
            })?;
        }
        Ok(())
    }
}

#[cfg(feature = "semantic-policy")]
type InitialPrefillSealSource = (u64, u64, Arc<TrackedCudaSlice<u64>>, usize);

#[cfg(feature = "semantic-policy")]
fn initial_prefill_seal_sources(
    content: &TensorContentBuffers,
) -> Result<Vec<InitialPrefillSealSource>, SemanticTransitionError> {
    let TensorContentSeals::Captured(digests) = &content.seals else {
        return Err(SemanticTransitionError::ObservationMismatch);
    };
    if content.tensors.len() != digests.len() {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    content
        .tensors
        .iter()
        .zip(digests)
        .map(|(tensor, digest)| {
            let CapturedTensorDigest::Tensor { cells, offset, .. } = digest else {
                return Err(SemanticTransitionError::ObservationMismatch);
            };
            if offset.checked_add(4).is_none_or(|end| end > cells.len()) {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            Ok((
                tensor.layout.role,
                tensor.layout.index,
                Arc::clone(cells),
                *offset,
            ))
        })
        .collect()
}

fn model_content_ranges(
    directory: &[PublicationRange],
    layouts: &BTreeMap<(u64, u64), SemanticTensorLayout>,
    tensors: impl Iterator<Item = (SemanticTensorLayout, u64, u64, usize)>,
) -> Result<Vec<usize>, SemanticTransitionError> {
    // This cold plan fixes geometry only. The original device reader selects
    // and authenticates the model record before its expected seals are copied.
    if directory.iter().filter(|range| range.role == 44).count() != 1
        || !directory.iter().any(|range| {
            range.role == 44 && range.index == 0 && range.generation == 1 && range.length_bytes != 0
        })
        || !directory.iter().any(|range| range.role == 18)
    {
        return Err(publication_input_error(
            "model content requires the complete original roster and sealed model contract",
        ));
    }
    let expected: BTreeSet<_> = directory
        .iter()
        .filter(|range| matches!(range.role, 18..=20))
        .map(|range| (range.role, range.index))
        .collect();
    let mut seen = BTreeSet::new();
    let mut ranges = Vec::new();
    for (actual, begin, end, bytes) in tensors {
        let key = (actual.role, actual.index);
        if !expected.contains(&key) || !seen.insert(key) {
            return Err(publication_input_error(
                "model content must name each original model tensor exactly once",
            ));
        }
        tensor_content_range(&actual, begin, end, bytes)?;
        let (ordinal, range) = directory
            .iter()
            .enumerate()
            .find(|(_, range)| (range.role, range.index) == key)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let mut original = *layouts
            .get(&key)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if original.logical_axis != u64::MAX {
            let axis = usize::try_from(original.logical_axis)
                .ok()
                .filter(|&axis| axis < 4)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            original.dimensions[axis] = range
                .logical_end
                .checked_sub(range.logical_begin)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
        }
        // Logical content includes type, shape and interval, but neither the
        // producer address nor its valid, independently checked physical strides.
        original.strides_bytes = actual.strides_bytes;
        if original != actual
            || range.generation != 1
            || (range.logical_begin, range.logical_end) != (begin, end)
        {
            return Err(publication_input_error(
                "live model tensor differs from the original logical type, shape or interval",
            ));
        }
        ranges.push(ordinal);
    }
    if seen != expected {
        return Err(publication_input_error(
            "model content omits an original model tensor",
        ));
    }
    Ok(ranges)
}

fn tensor_content_range(
    layout: &SemanticTensorLayout,
    begin: u64,
    end: u64,
    bytes: usize,
) -> Result<PublicationRange, SemanticTransitionError> {
    if (layout.role != 0 && SemanticStateRole::from_code(layout.role).is_none())
        || end < begin
        || tensor_layout_bytes(layout)? != bytes
        || if layout.logical_axis == u64::MAX {
            begin != 0 || end != 0
        } else {
            end - begin != layout.dimensions[layout.logical_axis as usize]
        }
    {
        return Err(publication_input_error(
            "content tensor must retain its exact type, shape, interval and byte extent",
        ));
    }
    Ok(PublicationRange {
        role: layout.role,
        index: layout.index,
        length_bytes: bytes as u64,
        logical_begin: begin,
        logical_end: end,
        ..PublicationRange::default()
    })
}

fn validate_content_coordinates(
    coordinates: impl Iterator<Item = (u64, u64)>,
) -> Result<(), SemanticTransitionError> {
    validate_content_coordinates_after(coordinates, 0)
}

fn validate_content_coordinates_after(
    coordinates: impl Iterator<Item = (u64, u64)>,
    private_prefix: usize,
) -> Result<(), SemanticTransitionError> {
    let mut distinct = BTreeSet::new();
    for (ordinal, (role, index)) in coordinates.enumerate() {
        if (role == 0
            && ordinal
                .checked_sub(private_prefix)
                .is_none_or(|allocation| index != allocation as u64))
            || (role != 0 && SemanticStateRole::from_code(role).is_none())
            || !distinct.insert((role, index))
        {
            return Err(publication_input_error(
                "content coordinates require unique state roles or exact private capture positions",
            ));
        }
    }
    Ok(())
}

/// An actual device-acquired reader. Only its originating Session can inspect,
/// export or release it; it is neither cloneable nor externally constructible.
pub struct SemanticPublishedLease {
    issuer: Arc<()>,
    token: u64,
    identity: SemanticPublishedIdentity,
    header: PublicationHeader,
    source: [SemanticTextSlot; 32],
    directory: Vec<PublicationRange>,
    active: bool,
}

fn committed_prefix_layout(
    range: &PublicationRange,
    prefix_capacity: u64,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    let row_bytes = size_of::<SemanticTextSlot>() as u64;
    if range.role != SemanticStateRole::PrefixSource as u64
        || range.index != 0
        || range.logical_begin != 0
        || range.logical_end > prefix_capacity
        || range.logical_end.checked_mul(row_bytes) != Some(range.length_bytes)
        || i64::try_from(prefix_capacity).is_err()
        || !range
            .offset_bytes
            .is_multiple_of(std::mem::align_of::<SemanticTextSlot>() as u64)
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let layout = SemanticTensorLayout {
        role: SemanticStateRole::PrefixSource as u64,
        index: 0,
        scalar_type: 3,
        element_bytes: 8,
        rank: 2,
        logical_axis: 0,
        dimensions: [prefix_capacity, 8, 0, 0],
        strides_bytes: [row_bytes, 8, 0, 0],
    };
    tensor_layout_bytes(&layout)?;
    Ok(layout)
}

/// Bound a view using its cold geometry without widening the sealed logical
/// range. Only prefix/cache owners expose reserved row capacity. Other records
/// and model tensors remain bounded by their complete original sealed extent.
fn publication_export_span(
    range: &PublicationRange,
    layout: &SemanticTensorLayout,
    allocation_bytes: usize,
) -> Result<std::ops::Range<usize>, SemanticTransitionError> {
    let bytes = tensor_layout_bytes(layout)?;
    let begin = usize::try_from(range.offset_bytes)
        .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
    let sealed_bytes = usize::try_from(range.length_bytes)
        .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
    let capacity = matches!(range.role, 1 | 4 | 5 | 51..=54);
    if range.generation != 1
        || (range.role, range.index) != (layout.role, layout.index)
        || !range.offset_bytes.is_multiple_of(layout.element_bytes)
        || begin
            .checked_add(sealed_bytes)
            .is_none_or(|end| end > allocation_bytes)
        || range.logical_end < range.logical_begin
        || (layout.logical_axis != u64::MAX
            && (range.logical_begin != 0
                || range.logical_end > layout.dimensions[layout.logical_axis as usize]))
        || (!capacity && bytes > sealed_bytes)
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let end = begin
        .checked_add(bytes.max(sealed_bytes))
        .filter(|&end| end <= allocation_bytes)
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    Ok(begin..end)
}

fn publication_record_layout(range: &PublicationRange) -> SemanticTensorLayout {
    SemanticTensorLayout {
        role: range.role,
        index: range.index,
        element_bytes: 1,
        scalar_type: 1,
        rank: 1,
        logical_axis: u64::MAX,
        dimensions: [range.length_bytes, 0, 0, 0],
        strides_bytes: [1, 0, 0, 0],
    }
}

impl SemanticPublishedLease {
    fn model_context_header(&self) -> Result<PublicationHeader, SemanticTransitionError> {
        let header = self.header;
        if header.abi != 1
            || header.instance != self.identity.instance
            || header.publication_word != self.identity.word
            || header.sealed_epoch != self.identity.word >> 1
            || header.logical_digest != self.identity.logical_digest
            || header.state_digest != self.identity.state_digest
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(header)
    }
}

/// Value-independent flat coordinates emitted by the native feedback producer.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticFeedbackSchema {
    pub identity: [u8; 32],
    pub statement_bytes: usize,
    pub feature_width: usize,
}

impl SemanticFeedbackSchema {
    pub fn new(statements: [&[u8]; 3]) -> Result<Self, SemanticTransitionError> {
        if statements.iter().any(|statement| statement.is_empty()) {
            return Err(publication_input_error(
                "native feedback requires three nonempty typed statements",
            ));
        }
        let statement_bytes = statements
            .iter()
            .map(|statement| statement.len())
            .max()
            .unwrap();
        let feature_width = statement_bytes
            .checked_mul(9)
            .and_then(|n| n.checked_add(4))
            .filter(|&n| i64::try_from(n).is_ok())
            .ok_or_else(|| publication_input_error("native feedback schema width overflows"))?;
        let mut hash = Sha256::new();
        hash.update(b"xlog.feedback.flat-bit-presence.v1\0");
        hash.update((statement_bytes as u64).to_le_bytes());
        hash.update(b"byte[i]:bits[0..8],presence;pro,1,contra,1;invalid:all-zero");
        Ok(Self {
            identity: hash.finalize().into(),
            statement_bytes,
            feature_width,
        })
    }
}

/// Named columns of each current feedback support row. These service values do
/// not enter the learned feature schema. Rows follow newest-to-oldest ancestry.
pub const SEMANTIC_FEEDBACK_SUPPORT_FIELDS: [&str; 12] = [
    "original_statement",
    "original_support",
    "support_slot",
    "support_generation",
    "version_slot",
    "version_generation",
    "insertion_ordinal",
    "polarity",
    "support_digest_0",
    "support_digest_1",
    "support_digest_2",
    "support_digest_3",
];

/// Features, validity and current causal provenance from one acquired bank.
/// Original outputs retain their step independently of later bank retirement.
pub struct SemanticFeedback {
    pub parent: SemanticPublishedIdentity,
    pub schema: SemanticFeedbackSchema,
    features: DlpackManagedTensor,
    device_validity: DlpackManagedTensor,
    query_receipts: DlpackManagedTensor,
    original_statements: DlpackManagedTensor,
    support_offsets: DlpackManagedTensor,
    supports: DlpackManagedTensor,
}

impl SemanticFeedback {
    /// Features, validity, opaque native current receipts, original statement
    /// indices, support offsets, and named support rows, respectively. All
    /// service tensors are U64. Invalid slots have no receipt/contributors and
    /// original index U64::MAX; valid Neither has an original index and no rows.
    pub fn into_dlpack(self) -> [DlpackManagedTensor; 6] {
        [
            self.features,
            self.device_validity,
            self.query_receipts,
            self.original_statements,
            self.support_offsets,
            self.supports,
        ]
    }
}

struct FeedbackBuffers {
    schema: SemanticFeedbackSchema,
    slots: usize,
    support_capacity: usize,
    encode: CudaFunction,
    project: CudaFunction,
    witness: CudaFunction,
    content: TensorContentBuffers,
    features: TrackedCudaSlice<f32>,
    validity: TrackedCudaSlice<u8>,
    status: TrackedCudaSlice<u64>,
    query_receipts: TrackedCudaSlice<u64>,
    original_statements: TrackedCudaSlice<u64>,
    support_offsets: TrackedCudaSlice<u64>,
    supports: TrackedCudaSlice<u64>,
}

#[derive(Clone, Copy)]
struct FeedbackAllocationPlan {
    slots: usize,
    support_capacity: usize,
    cells: usize,
    query_cells: usize,
    support_cells: usize,
    offset_cells: usize,
    bytes: usize,
}

impl FeedbackAllocationPlan {
    fn new(
        schema: &SemanticFeedbackSchema,
        slots: u64,
        support_capacity: u64,
    ) -> Result<Self, SemanticTransitionError> {
        let slots = usize::try_from(slots)
            .ok()
            .filter(|&n| n >= 2 && i64::try_from(n).is_ok())
            .ok_or_else(|| {
                publication_input_error("feedback slot capacity is not representable")
            })?;
        let support_capacity = usize::try_from(support_capacity)
            .ok()
            .filter(|&n| n != 0 && i64::try_from(n).is_ok())
            .ok_or_else(|| {
                publication_input_error("feedback support capacity is not representable")
            })?;
        let cells = slots
            .checked_mul(schema.feature_width)
            .ok_or_else(|| publication_input_error("feedback feature extent overflows"))?;
        let query_cells = slots
            .checked_mul(42)
            .ok_or_else(|| publication_input_error("feedback receipt extent overflows"))?;
        let support_cells = support_capacity
            .checked_mul(SEMANTIC_FEEDBACK_SUPPORT_FIELDS.len())
            .ok_or_else(|| publication_input_error("feedback support extent overflows"))?;
        let offset_cells = slots
            .checked_add(1)
            .ok_or_else(|| publication_input_error("feedback offset extent overflows"))?;
        let service_bytes = query_cells
            .checked_add(slots)
            .and_then(|n| n.checked_add(offset_cells))
            .and_then(|n| n.checked_add(support_cells))
            .and_then(|n| n.checked_mul(8))
            .ok_or_else(|| publication_input_error("feedback service extent overflows"))?;
        let bytes = cells
            .checked_mul(size_of::<f32>())
            .and_then(|n| {
                slots
                    .checked_mul(9)
                    .and_then(|metadata| n.checked_add(metadata))
            })
            .and_then(|n| n.checked_add(service_bytes))
            .and_then(|n| n.checked_add(6 * 4 * size_of::<u64>()))
            .ok_or_else(|| publication_input_error("feedback allocation extent overflows"))?;
        Ok(Self {
            slots,
            support_capacity,
            cells,
            query_cells,
            support_cells,
            offset_cells,
            bytes,
        })
    }
}

impl FeedbackBuffers {
    // Cold preparation only. The same fixed outputs and kernels are used by
    // enqueue; no acquired parent, device values or digest is cached here.
    fn allocate(
        provider: &CudaKernelProvider,
        schema: SemanticFeedbackSchema,
        slots: u64,
        support_capacity: u64,
    ) -> Result<Self, SemanticTransitionError> {
        let plan = FeedbackAllocationPlan::new(&schema, slots, support_capacity)?;
        let mut reservation = provider
            .memory()
            .reserve_bytes(plan.bytes as u64)
            .map_err(|error| runtime_error("feedback reservation", error))?;
        Self::allocate_reserved(provider, schema, plan, &mut reservation)
    }

    fn allocate_reserved(
        provider: &CudaKernelProvider,
        schema: SemanticFeedbackSchema,
        plan: FeedbackAllocationPlan,
        reservation: &mut GpuMemoryReservation,
    ) -> Result<Self, SemanticTransitionError> {
        let FeedbackAllocationPlan {
            slots,
            support_capacity,
            cells,
            query_cells,
            support_cells,
            offset_cells,
            ..
        } = plan;
        let encode = provider
            .device()
            .inner()
            .get_func("xlog_semantic_transition", "semantic_feedback_encode")
            .ok_or_else(|| {
                runtime_error("kernel lookup", "semantic feedback kernel unavailable")
            })?;
        let project = provider
            .device()
            .inner()
            .get_func("xlog_semantic_transition", "semantic_feedback_project")
            .ok_or_else(|| {
                runtime_error("kernel lookup", "semantic feedback projection unavailable")
            })?;
        let witness = provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_tensor_content_witness",
            )
            .ok_or_else(|| runtime_error("kernel lookup", "tensor content witness unavailable"))?;
        let mut buffers = Self {
            schema,
            slots,
            support_capacity,
            encode,
            project,
            witness,
            content: TensorContentBuffers {
                tensors: Vec::new(),
                seals: TensorContentSeals::Captured(Vec::new()),
                verification_inputs: Vec::new(),
            },
            features: reservation
                .alloc::<f32>(cells)
                .map_err(|error| runtime_error("feedback features allocation", error))?,
            validity: reservation
                .alloc::<u8>(slots)
                .map_err(|error| runtime_error("feedback validity allocation", error))?,
            status: reservation
                .alloc::<u64>(slots)
                .map_err(|error| runtime_error("feedback status allocation", error))?,
            query_receipts: reservation
                .alloc::<u64>(query_cells)
                .map_err(|error| runtime_error("feedback receipt allocation", error))?,
            original_statements: reservation
                .alloc::<u64>(slots)
                .map_err(|error| runtime_error("feedback origin allocation", error))?,
            support_offsets: reservation
                .alloc::<u64>(offset_cells)
                .map_err(|error| runtime_error("feedback offset allocation", error))?,
            supports: reservation
                .alloc::<u64>(support_cells)
                .map_err(|error| runtime_error("feedback support allocation", error))?,
        };
        let words = |view: DeviceMemoryView<u64>| {
            // SAFETY: u64 has no padding. The byte view retains the original
            // tracked allocation, without a managed alias that owns its reader.
            unsafe { view.cast::<u8>() }.ok_or(SemanticTransitionError::ObservationMismatch)
        };
        // SAFETY: f32 has no padding and the byte view retains its real owner.
        let features = unsafe { buffers.features.view().cast::<u8>() }
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let originals = [
            features,
            buffers.validity.view(),
            words(buffers.query_receipts.view())?,
            words(buffers.original_statements.view())?,
            words(buffers.support_offsets.view())?,
            words(buffers.supports.view())?,
        ];
        let shapes = [
            (
                6,
                4,
                2,
                [slots as u64, buffers.schema.feature_width as u64, 0, 0],
            ),
            (8, 1, 1, [slots as u64, 0, 0, 0]),
            (3, 8, 2, [slots as u64, 42, 0, 0]),
            (3, 8, 1, [slots as u64, 0, 0, 0]),
            (3, 8, 1, [offset_cells as u64, 0, 0, 0]),
            (3, 8, 2, [support_capacity as u64, 12, 0, 0]),
        ];
        let mut digests = Vec::with_capacity(originals.len());
        for (index, (source, (scalar_type, element_bytes, rank, dimensions))) in
            originals.into_iter().zip(shapes).enumerate()
        {
            let layout = canonical_tensor_layout(SemanticTensorLayout {
                role: 0,
                index: index as u64,
                scalar_type,
                element_bytes,
                rank,
                dimensions,
                logical_axis: u64::MAX,
                strides_bytes: [0; 4],
            })?;
            tensor_content_range(&layout, 0, 0, source.len())?;
            buffers.content.tensors.push(PreparedSemanticTensor {
                layout,
                logical_begin: 0,
                logical_end: 0,
                data: *source.device_ptr(),
                source: Some(source),
                native_allocation: None,
                _empty_owner: None,
            });
            digests.push(CapturedTensorDigest::Tensor {
                cells: Arc::new(
                    reservation
                        .alloc::<u64>(4)
                        .map_err(|error| runtime_error("feedback witness allocation", error))?,
                ),
                offset: 0,
                producer_sealed: false,
            });
        }
        buffers.content.seals = TensorContentSeals::Captured(digests);
        Ok(buffers)
    }

    // The caller retains these prepared outputs before the first may-enqueue
    // boundary, including failures and unwinding. This path does not allocate
    // device storage, export tensors, synchronize or insert stream joins.
    #[expect(
        clippy::too_many_arguments,
        reason = "feedback execution records every retained native owner explicitly"
    )]
    fn enqueue(
        &self,
        domain: &ResidentExecutionDomain,
        poisoned: &mut bool,
        graph: &SemanticHypergraph,
        storage: &PublicationStorage,
        task: &TrackedCudaSlice<u64>,
        lease: &TrackedCudaSlice<PublicationLease>,
        descriptor: Descriptor,
    ) -> Result<(), SemanticTransitionError> {
        let mut recorder = domain.new_strict_recorder();
        recorder.read(lease);
        recorder.read(&storage.control);
        recorder.read(&storage.storage);
        recorder.read(&storage.contract);
        for bank in &storage.banks {
            recorder.read(bank);
        }
        for directory in &storage.directories {
            recorder.read(directory);
        }
        for allocation in &storage.allocations {
            recorder.read(allocation);
        }
        recorder.write(&self.features);
        recorder.write(&self.validity);
        recorder.write(&self.status);
        let arguments = (
            storage.control.device_ptr_value(),
            lease.device_ptr_value(),
            self.schema.statement_bytes as u64,
            self.slots as u64,
            self.features.device_ptr_value(),
            self.validity.device_ptr_value(),
            self.status.device_ptr_value(),
        );
        enqueue_recorded(domain, poisoned, recorder, |stream| {
            // SAFETY: both directories and every selectable allocation are
            // retained. The kernel resolves and validates the acquired lease's
            // original ranges; output extents were checked during preparation.
            unsafe {
                self.encode.clone().launch_in(
                    stream,
                    LaunchConfig {
                        grid_dim: (self.slots.min(65535) as u32, 1, 1),
                        block_dim: (256, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        let mut recorder = domain.new_strict_recorder();
        graph.record_transition(&mut recorder);
        storage.record(&mut recorder);
        recorder.read(lease);
        recorder.read(task);
        recorder.read_write(&self.status);
        recorder.write(&self.query_receipts);
        recorder.write(&self.original_statements);
        recorder.write(&self.support_offsets);
        recorder.write(&self.supports);
        let arguments = (
            descriptor,
            lease.device_ptr_value(),
            self.slots as u64,
            self.query_receipts.device_ptr_value(),
            self.original_statements.device_ptr_value(),
            self.support_offsets.device_ptr_value(),
            self.supports.device_ptr_value(),
            self.support_capacity as u64,
            self.status.device_ptr_value(),
        );
        enqueue_recorded(domain, poisoned, recorder, |stream| {
            // SAFETY: the original task, actual arena and publication owners
            // are recorded. Lineage is queried from this device-acquired parent,
            // never a captured host selection or detached feedback record.
            unsafe {
                self.project.clone().launch_in(
                    stream,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        // The first seal follows the genuine encoder and lineage producer on
        // the same stream, before any dependent consumer receives an alias.
        self.content.enqueue(domain, poisoned, &self.witness, false)
    }
}

impl SemanticPublishedLease {
    pub fn is_active(&self) -> bool {
        self.active
    }
}

#[expect(
    clippy::too_many_arguments,
    reason = "DLPack export retains independent shape, type, alias, and publication owners"
)]
fn export_owned_allocation(
    view: DeviceMemoryView<u8>,
    shape: Vec<i64>,
    strides: Vec<i64>,
    dtype: (u8, u8),
    device_id: i32,
    alias_guard: Arc<()>,
    publication: Arc<PublicationStorage>,
    continuation: Option<Arc<TextBindingStorage>>,
    retained_owner: Option<Arc<dyn Send + Sync>>,
) -> DlpackManagedTensor {
    let mut export = Box::new(PublishedTensorExport {
        managed: crate::dlpack::DLManagedTensor {
            dl_tensor: crate::dlpack::DLTensor {
                data: *view.device_ptr() as usize as *mut std::ffi::c_void,
                device: crate::dlpack::DLDevice {
                    device_type: 2,
                    device_id,
                },
                ndim: shape.len() as i32,
                dtype: crate::dlpack::DLDataType {
                    code: dtype.0,
                    bits: dtype.1,
                    lanes: 1,
                },
                shape: std::ptr::null_mut(),
                strides: std::ptr::null_mut(),
                byte_offset: 0,
            },
            manager_ctx: std::ptr::null_mut(),
            deleter: Some(delete_published_tensor),
        },
        shape,
        strides,
        _view: view,
        _alias_guard: alias_guard,
        _publication: publication,
        _continuation: continuation,
        _retained_owner: retained_owner,
    });
    export.managed.dl_tensor.shape = export.shape.as_mut_ptr();
    export.managed.dl_tensor.strides = export.strides.as_mut_ptr();
    let owner = Box::into_raw(export);
    // SAFETY: the stable owner contains the genuine native allocation and its
    // exact metadata. Its bank or step keeps storage through final completion.
    unsafe {
        (*owner).managed.manager_ctx = owner.cast();
        DlpackManagedTensor::from_raw(&mut (*owner).managed)
    }
}

struct PublishedTensorExport {
    managed: crate::dlpack::DLManagedTensor,
    shape: Vec<i64>,
    strides: Vec<i64>,
    _view: DeviceMemoryView<u8>,
    _alias_guard: Arc<()>,
    _publication: Arc<PublicationStorage>,
    _continuation: Option<Arc<TextBindingStorage>>,
    _retained_owner: Option<Arc<dyn Send + Sync>>,
}

unsafe extern "C" fn delete_published_tensor(managed: *mut crate::dlpack::DLManagedTensor) {
    if managed.is_null() {
        return;
    }
    // SAFETY: this callback owns exactly the Box installed below. DLPack
    // transfers its managed record once; no unrelated pointer is accepted.
    let owner = unsafe { (*managed).manager_ctx.cast::<PublishedTensorExport>() };
    if !owner.is_null() {
        drop(unsafe { Box::from_raw(owner) });
    }
}

fn dlpack_consumer_stream(stream: u64) -> Result<sys::CUstream, SemanticTransitionError> {
    if matches!(stream, 0 | 2) {
        return Err(publication_input_error("DLPack consumer requires legacy default stream 1 or an explicit live stream; zero and per-thread default are unsupported"));
    }
    Ok(if stream == 1 {
        std::ptr::null_mut()
    } else {
        stream as usize as sys::CUstream
    })
}

// Every call below uses the fixed integral, padding-free publication ABI checked
// above, or SourceSlot's checked eight-u64 layout. This is cold control metadata.
fn publication_abi_bytes<T: DeviceRepr>(records: &[T]) -> Vec<u8> {
    // SAFETY: callers use initialized padding-free C ABI records only. The byte
    // slice is bounded by the live input allocation and copied before return.
    unsafe { std::slice::from_raw_parts(records.as_ptr().cast(), std::mem::size_of_val(records)) }
        .to_vec()
}

fn initial_intent_records(
    effect: &[u8],
    entry_capacity: u64,
    payload_capacity: usize,
    final_payload_bytes: u64,
) -> Result<[SemanticStateRecord; 2], SemanticTransitionError> {
    let entries_bytes = usize::try_from(entry_capacity)
        .ok()
        .and_then(|count| count.checked_mul(size_of::<IntentEntry>()))
        .and_then(|bytes| bytes.checked_add(size_of::<IntentQueueHeader>()))
        .ok_or_else(|| {
            publication_input_error("intent entry capacity overflows its native allocation")
        })?;
    let required_payload = u64::try_from(effect.len())
        .ok()
        .and_then(|bytes| bytes.checked_add(final_payload_bytes));
    if effect.is_empty()
        || entry_capacity == 0
        || final_payload_bytes == 0
        || required_payload.is_none_or(|bytes| bytes > payload_capacity as u64)
    {
        return Err(publication_input_error(
            "initial intent requires its actual effect and reserved final-output capacity",
        ));
    }
    let header = IntentQueueHeader {
        abi: 1,
        count: 0,
        capacity: entry_capacity,
        payload_used_bytes: effect.len() as u64,
        payload_capacity_bytes: payload_capacity as u64,
        effect_offset_bytes: 0,
        effect_length_bytes: effect.len() as u64,
        chain_head: Identity256::default(),
    };
    Ok([
        SemanticStateRecord {
            role: SemanticStateRole::IntentEntries,
            index: 0,
            bytes: publication_abi_bytes(&[header]),
            capacity_bytes: entries_bytes,
        },
        SemanticStateRecord {
            role: SemanticStateRole::IntentPayload,
            index: 0,
            bytes: effect.to_vec(),
            capacity_bytes: payload_capacity,
        },
    ])
}

fn initial_acknowledgement_record(
    entry_capacity: u64,
    payload_capacity: usize,
    intent_payload_capacity: usize,
    effect_len: usize,
) -> Result<SemanticStateRecord, SemanticTransitionError> {
    let count = usize::try_from(entry_capacity).map_err(|_| {
        publication_input_error("acknowledgement entry capacity overflows this host")
    })?;
    let required_receipts = count
        .checked_mul(169)
        .and_then(|bytes| bytes.checked_add(intent_payload_capacity))
        .and_then(|bytes| bytes.checked_add(count.saturating_sub(1).checked_mul(effect_len)?))
        .ok_or_else(|| {
            publication_input_error("complete acknowledgement reserve overflows this host")
        })?;
    let capacity_bytes = usize::try_from(entry_capacity)
        .ok()
        .and_then(|count| count.checked_mul(size_of::<AcknowledgementEntry>()))
        .and_then(|bytes| bytes.checked_add(payload_capacity))
        .and_then(|bytes| bytes.checked_add(size_of::<AcknowledgementQueueHeader>()))
        .ok_or_else(|| {
            publication_input_error("acknowledgement capacity overflows its native allocation")
        })?;
    if entry_capacity == 0 || effect_len == 0 || payload_capacity < required_receipts {
        return Err(publication_input_error("acknowledgement queue cannot retain every full receipt within its native intent bounds"));
    }
    Ok(SemanticStateRecord {
        role: SemanticStateRole::Acknowledgements,
        index: 0,
        bytes: publication_abi_bytes(&[AcknowledgementQueueHeader {
            abi: 1,
            count: 0,
            capacity: entry_capacity,
            payload_used_bytes: 0,
            payload_capacity_bytes: payload_capacity as u64,
            chain_head: Identity256::default(),
        }]),
        capacity_bytes,
    })
}

fn publication_mutable_role(role: u64) -> bool {
    matches!(role, 3..=15 | 18..=25 | 30 | 32 | 33 | 39 | 44 | 51..=55)
}

fn continuation_role(role: u64) -> bool {
    matches!(role, 1 | 4..=13 | 39 | 51..=55)
}

fn validate_parent_records(
    parent: &SemanticParentBinding,
    tensors: &[PreparedSemanticTensor],
) -> Result<(), SemanticTransitionError> {
    validate_publication_counts(&parent.role_counts)?;
    validate_text_parent(
        &parent.source,
        parent.prefix.len() as u64,
        parent.prefix_capacity,
        parent.feedback_capacity,
        parent.max_position,
        parent.ring_head,
        parent.provenance_records,
    )?;
    if parent.feedback_capacity < 3
        || parent.rng.stream_serial >= 1 << 56
        || u64::from(parent.rng.model_generation) != parent.model_generation
        || parent.pad_token >= TEXT_CARDINALITY as u64
        || parent.terminal_tokens.is_empty()
        || parent
            .terminal_tokens
            .iter()
            .any(|&token| token >= TEXT_CARDINALITY as u64)
        || parent
            .terminal_tokens
            .iter()
            .copied()
            .collect::<BTreeSet<_>>()
            .len()
            != parent.terminal_tokens.len()
    {
        return Err(publication_input_error(
            "parent generations, feedback extent, or token contract mismatch",
        ));
    }
    for (position, slot) in parent.prefix.iter().enumerate() {
        if slot.kind != 1
            || slot.valid != 1
            || slot.committed != 1
            || slot.logical_position != position as u64
            || slot.token >= TEXT_CARDINALITY as u64
            || !matches!(slot.provenance, 1 | 2)
            || slot.provenance_record >= parent.provenance_records
            || slot.recomputed > 1
        {
            return Err(publication_input_error(
                "committed prefix source is not the exact ordered valid prefix",
            ));
        }
    }
    let mut keys = BTreeSet::new();
    for record in &parent.records {
        let role = record.role as u64;
        if is_tensor_role(role)
            || matches!(role, 1 | 3 | 14..=16 | 33 | 43 | 47 | 48 | 55)
            || record.index >= parent.role_counts[role as usize - 1]
            || (record.bytes.is_empty() && role != 2)
            || record.bytes.len() > record.capacity_bytes
            || !keys.insert((role, record.index))
        {
            return Err(publication_input_error(
                "duplicate, generated, tensor, empty, or out-of-capacity control record",
            ));
        }
        if role == 2
            && (parent
                .provenance_records
                .checked_mul(size_of::<TokenProvenance>() as u64)
                != Some(record.bytes.len() as u64)
                || (parent.provenance_records + 32)
                    .checked_mul(size_of::<TokenProvenance>() as u64)
                    .is_none_or(|n| n > record.capacity_bytes as u64))
        {
            return Err(publication_input_error(
                "token provenance records or append capacity differ from the actual source ledger",
            ));
        }
        if role == 44 {
            parent
                .model_contract_layout
                .validate(record.bytes.len() as u64)?;
        }
        if role == 30 {
            if record.bytes.len() < size_of::<IntentQueueHeader>() {
                return Err(publication_input_error(
                    "intent queue has no complete owner header",
                ));
            }
            // SAFETY: complete checked header bytes, integral padding-free ABI.
            let header = unsafe {
                record
                    .bytes
                    .as_ptr()
                    .cast::<IntentQueueHeader>()
                    .read_unaligned()
            };
            if header.abi != 1
                || header.count > header.capacity
                || header
                    .count
                    .checked_mul(size_of::<IntentEntry>() as u64)
                    .and_then(|n| n.checked_add(size_of::<IntentQueueHeader>() as u64))
                    != Some(record.bytes.len() as u64)
                || header
                    .capacity
                    .checked_mul(size_of::<IntentEntry>() as u64)
                    .and_then(|n| n.checked_add(size_of::<IntentQueueHeader>() as u64))
                    != Some(record.capacity_bytes as u64)
                || header.payload_used_bytes > header.payload_capacity_bytes
                || header.effect_length_bytes == 0
                || header
                    .effect_offset_bytes
                    .checked_add(header.effect_length_bytes)
                    .is_none_or(|n| n > header.payload_used_bytes)
            {
                return Err(publication_input_error(
                    "intent queue count, capacity, or actual effect payload is inconsistent",
                ));
            }
            let payload = parent
                .records
                .iter()
                .find(|record| record.role == SemanticStateRole::IntentPayload)
                .ok_or_else(|| publication_input_error("intent queue payload owner is absent"))?;
            if payload.bytes.len() as u64 != header.payload_used_bytes
                || payload.capacity_bytes as u64 != header.payload_capacity_bytes
            {
                return Err(publication_input_error(
                    "intent queue does not resolve to its actual payload allocation",
                ));
            }
        }
        if role == 32 {
            acknowledgement_receipts(&record.bytes, record.capacity_bytes)?;
        }
    }
    for tensor in tensors {
        let layout = &tensor.layout;
        if !is_tensor_role(layout.role)
            || layout.role >= 51
            || layout.index >= parent.role_counts[layout.role as usize - 1]
            || !keys.insert((layout.role, layout.index))
        {
            return Err(publication_input_error("initial parent tensor role is duplicate, uncomputed-active, or outside its model roster"));
        }
        tensor_layout_bytes(layout)?;
        if matches!(layout.role, 4 | 5) {
            if tensor.logical_begin != 0
                || tensor.logical_end != parent.prefix.len() as u64
                || layout.dimensions[2] != parent.prefix.len() as u64
            {
                return Err(publication_input_error(
                    "initial attention tensor does not cover exactly the acquired prefix",
                ));
            }
            prefix_capacity_layout(*layout, parent.prefix_capacity)?;
        } else if layout.logical_axis != u64::MAX
            || (matches!(layout.role, 18..=25)
                && (tensor.logical_begin != 0 || tensor.logical_end != 0))
        {
            return Err(publication_input_error(
                "non-positional model tensors require a non-sliced exact layout",
            ));
        }
        if matches!(layout.role, 8..=13) && (layout.scalar_type != 6 || layout.element_bytes != 4) {
            return Err(publication_input_error(
                "value and edit accumulators require original FP32 storage",
            ));
        }
    }
    for layout in &parent.active_layouts {
        if !matches!(layout.role, 51..=54)
            || layout.index >= parent.role_counts[layout.role as usize - 1]
            || !keys.insert((layout.role, layout.index))
            || tensor_layout_bytes(layout)? == 0
        {
            return Err(publication_input_error("active output capacity layout is absent, duplicate, or outside the cold model roster"));
        }
        validate_active_capacity(
            layout,
            32u64
                .checked_add(parent.feedback_capacity)
                .ok_or_else(|| publication_input_error("active row capacity overflow"))?,
        )?;
    }
    for role in 1..=55u64 {
        if matches!(role, 1 | 3 | 14..=16 | 33 | 43 | 47 | 48 | 55) {
            continue;
        }
        for index in 0..parent.role_counts[role as usize - 1] {
            if !keys.contains(&(role, index)) {
                return Err(publication_input_error(
                    "publication role lacks its actual cold owner",
                ));
            }
        }
    }
    Ok(())
}

/// Validate the initial cold text import and derive its structural interval.
/// This establishes source metadata, not model completion or cache coverage.
fn validate_text_parent(
    slots: &[SourceSlot; 32],
    prefix_extent: u64,
    prefix_capacity: u64,
    feedback_capacity: u64,
    max_position: u64,
    ring_head: u64,
    provenance_records: u64,
) -> Result<u64, SemanticTransitionError> {
    let invalid = |detail: &str| SemanticTransitionError::InvalidInput {
        detail: detail.into(),
    };
    let text_limit = prefix_capacity
        .checked_add(32)
        .ok_or_else(|| invalid("text capacity overflow"))?;
    if prefix_extent > prefix_capacity
        || ring_head >= 32
        || text_limit
            .checked_add(feedback_capacity)
            .is_none_or(|limit| limit > max_position)
        || max_position != 262144
    {
        return Err(invalid("text prefix, ring or position capacity mismatch"));
    }
    let mut positions = BTreeSet::new();
    let mut filled = BTreeSet::new();
    for slot in slots {
        if slot.kind > 2
            || (if slot.kind == 2 {
                slot.token != MASK_TOKEN as u64
            } else {
                slot.token >= TEXT_CARDINALITY as u64
            })
        {
            return Err(invalid(
                "text token or row kind is outside its cold contract",
            ));
        }
        if slot.kind == 0 {
            if slot.logical_position != 0
                || slot.provenance != 0
                || slot.valid != 0
                || slot.committed != 0
                || slot.recomputed != 0
                || slot.provenance_record != 0
            {
                return Err(invalid("padding source slot carries active metadata"));
            }
            continue;
        }
        if slot.valid != 1
            || slot.committed != 0
            || slot.recomputed > 1
            || slot.logical_position < prefix_extent
            || slot.logical_position >= text_limit
            || !positions.insert(slot.logical_position)
        {
            return Err(invalid(
                "active source slot has inconsistent position or provenance",
            ));
        }
        if slot.kind == 1 {
            if !matches!(slot.provenance, 1 | 2) || slot.provenance_record >= provenance_records {
                return Err(invalid(
                    "filled source slot requires source or generated provenance",
                ));
            }
            filled.insert(slot.logical_position);
        } else if slot.provenance != 0 || slot.provenance_record != 0 || slot.recomputed != 0 {
            return Err(invalid(
                "mask source slot cannot carry filled-token coverage",
            ));
        }
    }
    let mut structural_end = prefix_extent;
    while filled.contains(&structural_end) {
        if structural_end == prefix_capacity {
            return Err(invalid(
                "contiguous source completion exceeds prefix capacity",
            ));
        }
        structural_end += 1;
    }
    Ok(structural_end)
}

#[repr(C)]
#[derive(Clone, Copy)]
struct Descriptor {
    logits: u64,
    support: u64,
    scratch: u64,
    receipts: u64,
    state: u64,
    components: u64,
    codebooks: u64,
    arena: [u64; 7],
    policy: PolicyDescriptor,
    backward: PolicyBackward,
    task: u64,
    task_words: u64,
    task_return_bound: u64,
    publication: PublicationCommand,
    text: TextBinding,
    model_work: ModelWorkInput,
    replay: PreparedReplayDescriptor,
}

#[derive(Clone, Copy)]
struct TransitionKernelPointers {
    logits: u64,
    support: u64,
    receipts: u64,
    state: u64,
    lease: u64,
    text: TextBinding,
    policy: PolicyDescriptor,
    model_work: ModelWorkInput,
}

impl Descriptor {
    fn with_transition(mut self, original: TransitionKernelPointers) -> Self {
        self.logits = original.logits;
        self.support = original.support;
        self.receipts = original.receipts;
        self.state = original.state;
        self.publication.lease = original.lease;
        self.text = original.text;
        self.policy = original.policy;
        self.model_work = original.model_work;
        self
    }
}

struct TransitionKernelIo<'a> {
    logits: &'a TrackedCudaSlice<f32>,
    support: &'a TrackedCudaSlice<u8>,
    receipts: &'a TrackedCudaSlice<SemanticTransitionReceipt>,
    state: &'a TrackedCudaSlice<DeviceState>,
    text: Option<&'a TextBindingStorage>,
    lease: Option<&'a TrackedCudaSlice<PublicationLease>>,
    model_work: Option<&'a PreparedModelWork>,
    replay_custody: Option<&'a PreparedReplayCustody>,
    model_update: Option<&'a PreparedModelUpdate>,
    training_selection: Option<&'a DeviceMemoryView<SemanticTrainingViewSelection>>,
    #[cfg(feature = "semantic-policy")]
    policy: Option<&'a PolicyStorage>,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PolicyField {
    embeddings: u64,
    biases: u64,
    cardinality: u32,
    null_category: i32,
    retained_offset: u64,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PolicyDescriptor {
    z: u64,
    recurrence: u64,
    positions: u64,
    hidden: u64,
    scores: u64,
    recurrent: u64,
    retained_scores: u64,
    retained_score_stride: u64,
    final_masks: u64,
    active_sets: u64,
    pwl_cells: u64,
    selected_score_vjps: u64,
    component_baselines: u64,
    fields: [PolicyField; 18],
    numerical: PolicyNumericalDescriptor,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PolicyNumericalDescriptor {
    parameter_errors: u64,
    baseline_errors: u64,
    parameter_domains: u64,
    text_domains: u64,
    baseline_domains: u64,
    hidden_errors: u64,
    score_errors: u64,
    recurrent_errors: u64,
    parameter_cells: u64,
    parameter_envelopes: u64,
    baseline_envelopes: u64,
    uniform: u64,
}

#[repr(C)]
#[derive(Clone, Copy)]
struct PolicyUniformDescriptor {
    outputs: [u64; 3],
    roots: [u64; 3],
    recurrent: u64,
    hidden: u64,
    scores: u64,
    recurrent_cotangents: u64,
    score_cotangents: u64,
    score_roots: u64,
    status: u64,
    work: u64,
    training_rows: u64,
    return_bound: u64,
    loss_coefficients: [f64; 4],
}

// SAFETY: repr(C) contains only plain scalar/pointer words; the cold native
// owner validates every extent and retains all addressed storage through use.
unsafe impl DeviceRepr for PolicyUniformDescriptor {}

#[cfg(feature = "semantic-policy")]
struct PolicyUniformBuffers {
    descriptor: TrackedCudaSlice<PolicyUniformDescriptor>,
    initial_descriptor: PolicyUniformDescriptor,
    outputs: [TrackedCudaSlice<f64>; 3],
    roots: [TrackedCudaSlice<f64>; 3],
    scratch: [TrackedCudaSlice<f64>; 6],
    status: TrackedCudaSlice<u64>,
    work: TrackedCudaSlice<u64>,
    execute: CudaFunction,
}

#[cfg(feature = "semantic-policy")]
impl PolicyUniformBuffers {
    fn record(&self, recorder: &mut LaunchRecorder) {
        recorder.read(&self.descriptor);
        for buffer in self.outputs.iter().chain(&self.roots).chain(&self.scratch) {
            recorder.read_write(buffer);
        }
        recorder.read_write(&self.status);
        recorder.read_write(&self.work);
    }
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PolicyBackward {
    cotangents: u64,
    parameters: u64,
    text: u64,
    baselines: u64,
    recurrent: u64,
    scores: u64,
    status: u64,
    parameter_cells: u64,
    text_cells: u64,
    selection: u64,
    objective: u64,
    objective_groups: u64,
    objective_group_members: u64,
    roster_rows: u64,
    origin_candidate: u64,
    origin_lease: u64,
    origin_bank: u64,
    mode: u64,
    member_ordinal: u64,
    critic_term: u64,
    numerical: PolicyAdjointNumericalDescriptor,
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct PolicyAdjointNumericalDescriptor {
    parameter_errors: u64,
    text_errors: u64,
    baseline_errors: u64,
    parameter_domains: u64,
    text_domains: u64,
    baseline_domains: u64,
    recurrent_errors: u64,
    score_errors: u64,
    coefficient_errors: u64,
    parameter_cotangents: u64,
    text_cotangents: u64,
    baseline_cotangents: u64,
}

#[cfg(feature = "semantic-policy")]
#[expect(
    clippy::too_many_arguments,
    reason = "policy VJP launch retains each original producer and destination explicitly"
)]
fn record_policy_vjp(
    domain: &ResidentExecutionDomain,
    poisoned: &mut bool,
    recorder: LaunchRecorder,
    execute: CudaFunction,
    descriptor: Descriptor,
    coefficients: &TrackedCudaSlice<f64>,
    score_cotangents: Option<&DeviceMemoryView<f64>>,
    baseline_snapshot: Option<&DeviceMemoryView<f32>>,
) -> Result<(), SemanticTransitionError> {
    enqueue_recorded(domain, poisoned, recorder, |enqueue| {
        // SAFETY: the recorder retains every forward/output allocation and,
        // for the external mode, the original cotangent producer. The
        // destination is the fixed F64 bank owned by this exact invocation.
        // The selected mode fills that bank inside the kernel from resident
        // objective/state owners and therefore performs no producer copy.
        unsafe {
            if let Some(score_cotangents) = score_cotangents {
                sys::cuMemcpyDtoDAsync_v2(
                    coefficients.device_ptr_value(),
                    *score_cotangents.device_ptr(),
                    COMPONENT_COUNT * 8,
                    enqueue.stream().cu_stream(),
                )
                .result()
                .map_err(|error| {
                    XlogError::Kernel(format!("policy cotangent snapshot: {error}"))
                })?;
            }
            if let Some(baseline_snapshot) = baseline_snapshot {
                sys::cuMemcpyDtoDAsync_v2(
                    descriptor.backward.baselines,
                    *baseline_snapshot.device_ptr(),
                    COMPONENT_COUNT * 4,
                    enqueue.stream().cu_stream(),
                )
                .result()
                .map_err(|error| XlogError::Kernel(format!("policy baseline snapshot: {error}")))?;
            }
            execute
                .launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (256, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (descriptor,),
                )
                .map_err(|error| XlogError::Kernel(format!("policy backward launch: {error}")))?;
        }
        Ok::<(), XlogError>(())
    })
}

/// Dedicated device-owned adjoints for one exact policy invocation. Their tracked
/// allocations can be consumed on another recorded stream without host copies.
#[cfg(feature = "semantic-policy")]
pub struct SemanticPolicyGradients {
    pub binding: SemanticCatalogueBinding,
    pub invocation: SemanticRngBinding,
    pub layout: SemanticPolicyLayout,
    pub parameters: TrackedCudaSlice<f32>,
    pub text_logits: TrackedCudaSlice<f32>,
    pub component_baselines: TrackedCudaSlice<f32>,
    numerical: Arc<PolicyAdjointNumerical>,
    provider: Arc<CudaKernelProvider>,
    step_aliases: Arc<()>,
    publication: Arc<PublicationStorage>,
    continuation: Arc<TextBindingStorage>,
    vjp_workspace: Arc<PolicyVjpWorkspace>,
    support_cells: usize,
}

#[cfg(feature = "semantic-policy")]
impl SemanticPolicyGradients {
    /// Export parameter, full MASK and baseline adjoints, then their three
    /// FP64 error envelopes and three selected magnitude/error bounds.
    /// Baseline adjoints are exact zeros for externally supplied score roots.
    /// Backward already ordered the caller's explicit consumer stream after the
    /// device error guard. Final step release joins that consumer's last use.
    pub fn into_dlpack(self) -> Result<[DlpackManagedTensor; 9], SemanticTransitionError> {
        let retained_owner: Arc<dyn Send + Sync> = self.vjp_workspace;
        export_policy_gradients(
            [
                self.parameters.into_bytes().view(),
                self.text_logits.into_bytes().view(),
                self.component_baselines.into_bytes().view(),
            ],
            &self.numerical,
            self.support_cells,
            self.layout.parameter_cells,
            self.provider.device().ordinal() as i32,
            self.step_aliases,
            self.publication,
            self.continuation,
            retained_owner,
        )
    }
}

/// Device-selected actor, critic and cost adjoints for one exact prepared
/// policy invocation. Every invocation in the prepared proposal roster may
/// consume its original tape; the resident selection predicates all but the
/// selected candidate to graph-connected zeros.
#[cfg(feature = "semantic-policy")]
pub struct SemanticSelectedPolicyGradients {
    pub binding: SemanticCatalogueBinding,
    pub invocation: SemanticRngBinding,
    pub layout: SemanticPolicyLayout,
    pub parameters: TrackedCudaSlice<f32>,
    pub text_logits: TrackedCudaSlice<f32>,
    pub component_baselines: TrackedCudaSlice<f32>,
    numerical: Arc<PolicyAdjointNumerical>,
    provider: Arc<CudaKernelProvider>,
    step_aliases: Arc<()>,
    publication: Arc<PublicationStorage>,
    continuation: Arc<TextBindingStorage>,
    vjp_workspace: Arc<PolicyVjpWorkspace>,
    support_cells: usize,
}

/// Device-selected policy roots recorded inside a prepared Update branch.
/// The retained native bank remains reusable while the mutually exclusive
/// Update branches are captured; every export is a fresh DLPack view.
#[cfg(feature = "semantic-policy")]
pub struct SemanticPreparedPolicyGradients {
    pub layout: SemanticPolicyLayout,
    parameters: DeviceMemoryView<f32>,
    text_logits: DeviceMemoryView<f32>,
    component_baselines: DeviceMemoryView<f32>,
    provider: Arc<CudaKernelProvider>,
    step_aliases: Arc<()>,
    publication: Arc<PublicationStorage>,
    continuation: Arc<TextBindingStorage>,
    owner: Arc<PolicyAdjointBuffers>,
    support_cells: usize,
}

/// One fixed FP32[1] device scalar reduced in frozen actor-group order inside
/// the prepared Update bank. Its value is detached from the model graph; the
/// corresponding critic adjoints are returned with each original policy VJP.
#[cfg(feature = "semantic-policy")]
pub struct SemanticPreparedGroupCritic {
    value: DeviceMemoryView<f32>,
    provider: Arc<CudaKernelProvider>,
    step_aliases: Arc<()>,
    publication: Arc<PublicationStorage>,
}

#[cfg(feature = "semantic-policy")]
impl SemanticPreparedGroupCritic {
    pub fn into_dlpack(self) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        Ok(export_owned_allocation(
            unsafe { self.value.cast::<u8>() }.expect("FP32 group critic byte view"),
            vec![1],
            vec![1],
            (2, 32),
            self.provider.device().ordinal() as i32,
            self.step_aliases,
            self.publication,
            None,
            None,
        ))
    }
}

#[cfg(feature = "semantic-policy")]
impl SemanticPreparedPolicyGradients {
    pub fn into_dlpack(self) -> Result<[DlpackManagedTensor; 9], SemanticTransitionError> {
        let retained_owner: Arc<dyn Send + Sync> = self.owner.clone();
        let values = [self.parameters, self.text_logits, self.component_baselines].map(|view| {
            // SAFETY: retained original FP32 adjoints have their exact byte span.
            unsafe { view.cast::<u8>() }.expect("FP32 policy adjoint byte view")
        });
        export_policy_gradients(
            values,
            &self.owner.numerical,
            self.support_cells,
            self.layout.parameter_cells,
            self.provider.device().ordinal() as i32,
            self.step_aliases,
            self.publication,
            self.continuation,
            retained_owner,
        )
    }
}

#[cfg(feature = "semantic-policy")]
impl SemanticSelectedPolicyGradients {
    /// Export parameter, full MASK and component-baseline adjoints, in that
    /// order. The baseline result is the direct critic root for the retained
    /// original model graph; actor and cost share the exact policy tape.
    pub fn into_dlpack(self) -> Result<[DlpackManagedTensor; 9], SemanticTransitionError> {
        let retained_owner: Arc<dyn Send + Sync> = self.vjp_workspace;
        export_policy_gradients(
            [
                self.parameters.into_bytes().view(),
                self.text_logits.into_bytes().view(),
                self.component_baselines.into_bytes().view(),
            ],
            &self.numerical,
            self.support_cells,
            self.layout.parameter_cells,
            self.provider.device().ordinal() as i32,
            self.step_aliases,
            self.publication,
            self.continuation,
            retained_owner,
        )
    }
}

#[cfg(feature = "semantic-policy")]
#[expect(
    clippy::too_many_arguments,
    reason = "all exports retain one original native tape and its final-use owners"
)]
fn export_policy_gradients(
    values: [DeviceMemoryView<u8>; 3],
    numerical: &PolicyAdjointNumerical,
    support_cells: usize,
    parameter_cells: usize,
    device: i32,
    step_aliases: Arc<()>,
    publication: Arc<PublicationStorage>,
    continuation: Arc<TextBindingStorage>,
    owner: Arc<dyn Send + Sync>,
) -> Result<[DlpackManagedTensor; 9], SemanticTransitionError> {
    let original = policy_numerical_producer_layouts(support_cells, parameter_cells)?;
    let mut text_error = original[7];
    text_error.dimensions[2] = 2;
    text_error.strides_bytes = [0; 4];
    let text_error = canonical_tensor_layout(text_error)?;
    // Native labels are interleaved per coordinate. The kernel explicitly
    // packs actor then full into these contiguous region-major exports.
    let layouts = [
        original[2],
        original[0],
        original[3],
        original[4],
        text_error,
        original[5],
        paired_cotangent_domain(original[6])?,
        paired_cotangent_domain(original[7])?,
        paired_cotangent_domain(original[8])?,
    ];
    let numerical_views = numerical.roots.iter().map(|buffer| {
        // SAFETY: numerical roots are retained aligned FP64 storage.
        unsafe { buffer.view().cast::<u8>() }.expect("FP64 policy numerical byte view")
    });
    let tensors = values
        .into_iter()
        .chain(numerical_views)
        .zip(layouts)
        .map(|(view, layout)| {
            let rank = layout.rank as usize;
            export_owned_allocation(
                view,
                layout.dimensions[..rank]
                    .iter()
                    .map(|&n| n as i64)
                    .collect(),
                layout.strides_bytes[..rank]
                    .iter()
                    .map(|&n| (n / layout.element_bytes) as i64)
                    .collect(),
                (2, (layout.element_bytes * 8) as u8),
                device,
                Arc::clone(&step_aliases),
                Arc::clone(&publication),
                Some(Arc::clone(&continuation)),
                Some(Arc::clone(&owner)),
            )
        })
        .collect::<Vec<_>>();
    Ok(tensors
        .try_into()
        .unwrap_or_else(|_| unreachable!("nine original policy gradient exports")))
}

#[cfg(feature = "semantic-policy")]
fn policy_producer_layouts(
    support_cells: usize,
    parameter_cells: usize,
) -> Result<[SemanticTensorLayout; 4], SemanticTransitionError> {
    let layout = |index, scalar_type, element_bytes, rank, dimensions| {
        canonical_tensor_layout(SemanticTensorLayout {
            role: 0,
            index,
            scalar_type,
            element_bytes,
            rank,
            dimensions,
            logical_axis: u64::MAX,
            strides_bytes: [0; 4],
        })
    };
    Ok([
        layout(0, 6, 4, 2, [32, TEXT_CARDINALITY as u64, 0, 0])?,
        layout(1, 8, 1, 1, [support_cells as u64, 0, 0, 0])?,
        layout(2, 6, 4, 1, [parameter_cells as u64, 0, 0, 0])?,
        layout(3, 6, 4, 2, [1, COMPONENT_COUNT as u64, 0, 0])?,
    ])
}

#[cfg(feature = "semantic-policy")]
fn policy_numerical_producer_layouts(
    support_cells: usize,
    parameter_cells: usize,
) -> Result<[SemanticTensorLayout; 9], SemanticTransitionError> {
    let values = policy_producer_layouts(support_cells, parameter_cells)?;
    let layout = |index, rank, dimensions| {
        canonical_tensor_layout(SemanticTensorLayout {
            role: 0,
            index,
            scalar_type: 9,
            element_bytes: 8,
            rank,
            dimensions,
            logical_axis: u64::MAX,
            strides_bytes: [0; 4],
        })
    };
    Ok([
        values[0],
        values[1],
        values[2],
        values[3],
        layout(4, 2, [parameter_cells as u64, 2, 0, 0])?,
        layout(5, 3, [1, COMPONENT_COUNT as u64, 2, 0])?,
        layout(6, 2, [parameter_cells as u64, 4, 0, 0])?,
        layout(7, 3, [32, TEXT_CARDINALITY as u64, 4, 0])?,
        layout(8, 3, [1, COMPONENT_COUNT as u64, 4, 0])?,
    ])
}

#[cfg(feature = "semantic-policy")]
struct PolicyNumericalBuffers {
    parameter_errors: TrackedCudaSlice<f64>,
    baseline_errors: TrackedCudaSlice<f64>,
    parameter_domains: TrackedCudaSlice<f64>,
    text_domains: TrackedCudaSlice<f64>,
    baseline_domains: TrackedCudaSlice<f64>,
    hidden_errors: TrackedCudaSlice<f64>,
    score_errors: TrackedCudaSlice<f64>,
    recurrent_errors: TrackedCudaSlice<f64>,
    parameter_envelopes: TrackedCudaSlice<f64>,
    baseline_envelopes: TrackedCudaSlice<f64>,
    uniform: Arc<PolicyUniformBuffers>,
}

#[cfg(feature = "semantic-policy")]
fn paired_cotangent_domain(
    mut layout: SemanticTensorLayout,
) -> Result<SemanticTensorLayout, SemanticTransitionError> {
    let rank = layout.rank as usize;
    layout.dimensions.copy_within(0..rank, 1);
    layout.dimensions[0] = 2;
    layout.rank += 1;
    layout.strides_bytes = [0; 4];
    canonical_tensor_layout(layout)
}

#[cfg(feature = "semantic-policy")]
fn enqueue_policy_uniform_domains(
    domain: &ResidentExecutionDomain,
    poisoned: &mut bool,
    buffers: &PolicyBuffers,
    components: &TrackedCudaSlice<SemanticComponent>,
    support: &TrackedCudaSlice<u8>,
) -> Result<(), SemanticTransitionError> {
    let mut recorder = domain.new_strict_recorder();
    recorder.read(&buffers.parameters);
    recorder.read(&buffers.component_baselines);
    recorder.read(components);
    recorder.read(support);
    buffers.numerical.record(&mut recorder);
    recorder.write(&buffers.numerical.uniform.descriptor);
    let descriptor = SemanticTransitionSession::retained_policy_descriptor(buffers);
    enqueue_recorded(domain, poisoned, recorder, |enqueue| {
        // SAFETY: cold reservation and the immutable descriptor bind disjoint
        // scratch, original snapshots and complete output capacities. The
        // recorder orders all nine producers and the private descriptor's
        // device initialization before this one native transfer.
        unsafe {
            buffers.numerical.uniform.execute.clone().launch_in(
                enqueue,
                LaunchConfig {
                    grid_dim: (1, 1, 1),
                    block_dim: (256, 1, 1),
                    shared_mem_bytes: 0,
                },
                (
                    descriptor,
                    buffers.numerical.uniform.initial_descriptor,
                    components.device_ptr_value(),
                    support.device_ptr_value(),
                ),
            )
        }
        .map_err(|error| XlogError::Kernel(error.to_string()))
    })
}

#[cfg(feature = "semantic-policy")]
fn export_policy_uniform_domains(
    buffers: &PolicyBuffers,
    support_cells: usize,
    device: i32,
    aliases: Arc<()>,
    publication: Arc<PublicationStorage>,
) -> Result<[DlpackManagedTensor; 3], SemanticTransitionError> {
    let original =
        policy_numerical_producer_layouts(support_cells, buffers.layout.parameter_cells)?;
    let owner: Arc<dyn Send + Sync> = buffers.numerical.uniform.clone();
    let tensors = buffers
        .numerical
        .uniform
        .outputs
        .iter()
        .zip([original[6], original[7], original[8]])
        .map(|(buffer, layout)| {
            let layout = paired_cotangent_domain(layout)?;
            let rank = layout.rank as usize;
            // SAFETY: the typed retained FP64 output allocation has the exact
            // native layout; no managed tensor or producer is fabricated.
            let view = unsafe { buffer.view().cast::<u8>() }.expect("FP64 domain byte view");
            Ok(export_owned_allocation(
                view,
                layout.dimensions[..rank]
                    .iter()
                    .map(|&n| n as i64)
                    .collect(),
                layout.strides_bytes[..rank]
                    .iter()
                    .map(|&n| (n / 8) as i64)
                    .collect(),
                (2, 64),
                device,
                Arc::clone(&aliases),
                Arc::clone(&publication),
                None,
                Some(Arc::clone(&owner)),
            ))
        })
        .collect::<Result<Vec<_>, SemanticTransitionError>>()?;
    Ok(tensors
        .try_into()
        .unwrap_or_else(|_| unreachable!("three uniform domain roots")))
}

#[cfg(feature = "semantic-policy")]
impl PolicyNumericalBuffers {
    fn buffers(&self) -> [&TrackedCudaSlice<f64>; 10] {
        [
            &self.parameter_errors,
            &self.baseline_errors,
            &self.parameter_domains,
            &self.text_domains,
            &self.baseline_domains,
            &self.hidden_errors,
            &self.score_errors,
            &self.recurrent_errors,
            &self.parameter_envelopes,
            &self.baseline_envelopes,
        ]
    }

    fn record(&self, recorder: &mut LaunchRecorder) {
        for buffer in self.buffers() {
            recorder.read_write(buffer);
        }
        self.uniform.record(recorder);
    }

    fn descriptor(&self, parameter_cells: usize) -> PolicyNumericalDescriptor {
        PolicyNumericalDescriptor {
            parameter_errors: self.parameter_errors.device_ptr_value(),
            baseline_errors: self.baseline_errors.device_ptr_value(),
            parameter_domains: self.parameter_domains.device_ptr_value(),
            text_domains: self.text_domains.device_ptr_value(),
            baseline_domains: self.baseline_domains.device_ptr_value(),
            hidden_errors: self.hidden_errors.device_ptr_value(),
            score_errors: self.score_errors.device_ptr_value(),
            recurrent_errors: self.recurrent_errors.device_ptr_value(),
            parameter_cells: parameter_cells as u64,
            parameter_envelopes: self.parameter_envelopes.device_ptr_value(),
            baseline_envelopes: self.baseline_envelopes.device_ptr_value(),
            uniform: self.uniform.descriptor.device_ptr_value(),
        }
    }
}

#[cfg(feature = "semantic-policy")]
struct PolicyBuffers {
    layout: SemanticPolicyLayout,
    parameters: TrackedCudaSlice<f32>,
    hidden: TrackedCudaSlice<f32>,
    scores: TrackedCudaSlice<f32>,
    retained_scores: TrackedCudaSlice<f32>,
    final_masks: TrackedCudaSlice<u8>,
    active_sets: TrackedCudaSlice<u8>,
    pwl_cells: TrackedCudaSlice<SemanticPolicyPwlCell>,
    selected_score_vjps: TrackedCudaSlice<SemanticPolicySelectedScoreVjp>,
    recurrent: TrackedCudaSlice<f32>,
    text_logits: TrackedCudaSlice<f32>,
    component_baselines: TrackedCudaSlice<f32>,
    numerical: PolicyNumericalBuffers,
    adjoints: Option<PolicyAdjointBuffers>,
    temporal_adjoints: Arc<PolicyAdjointBuffers>,
}

/// Reserved with the original forward tape, then consumed by its sole backward.
/// Output storage is never recycled into a later invocation's working banks.
#[cfg(feature = "semantic-policy")]
struct PolicyAdjointBuffers {
    parameters: TrackedCudaSlice<f32>,
    text_logits: TrackedCudaSlice<f32>,
    component_baselines: TrackedCudaSlice<f32>,
    recurrent: TrackedCudaSlice<f32>,
    scores: TrackedCudaSlice<f32>,
    coefficients: TrackedCudaSlice<f64>,
    status: TrackedCudaSlice<u64>,
    numerical: Arc<PolicyAdjointNumerical>,
}

#[cfg(feature = "semantic-policy")]
struct PolicyAdjointNumerical {
    roots: [TrackedCudaSlice<f64>; 6],
    recurrent_errors: TrackedCudaSlice<f64>,
    score_errors: TrackedCudaSlice<f64>,
    coefficient_errors: TrackedCudaSlice<f64>,
    root_cotangents: [TrackedCudaSlice<f64>; 3],
}

#[cfg(feature = "semantic-policy")]
impl PolicyAdjointNumerical {
    fn buffers(&self) -> [&TrackedCudaSlice<f64>; 12] {
        [
            &self.roots[0],
            &self.roots[1],
            &self.roots[2],
            &self.roots[3],
            &self.roots[4],
            &self.roots[5],
            &self.recurrent_errors,
            &self.score_errors,
            &self.coefficient_errors,
            &self.root_cotangents[0],
            &self.root_cotangents[1],
            &self.root_cotangents[2],
        ]
    }

    fn descriptor(&self) -> PolicyAdjointNumericalDescriptor {
        let pointers = self.buffers().map(TrackedCudaSlice::device_ptr_value);
        PolicyAdjointNumericalDescriptor {
            parameter_errors: pointers[0],
            text_errors: pointers[1],
            baseline_errors: pointers[2],
            parameter_domains: pointers[3],
            text_domains: pointers[4],
            baseline_domains: pointers[5],
            recurrent_errors: pointers[6],
            score_errors: pointers[7],
            coefficient_errors: pointers[8],
            parameter_cotangents: pointers[9],
            text_cotangents: pointers[10],
            baseline_cotangents: pointers[11],
        }
    }
}

/// Every allocation referenced by a recorded policy VJP but not exported as an
/// adjoint. Exported gradient owners retain this workspace so deferred CUDA work
/// cannot observe reclaimed scratch or producer memory.
#[cfg(feature = "semantic-policy")]
struct PolicyVjpWorkspace {
    _component_baselines: Option<TrackedCudaSlice<f32>>,
    _recurrent: TrackedCudaSlice<f32>,
    _scores: TrackedCudaSlice<f32>,
    coefficients: TrackedCudaSlice<f64>,
    _status: TrackedCudaSlice<u64>,
    score_cotangents: Option<DeviceMemoryView<f64>>,
    _numerical: Arc<PolicyAdjointNumerical>,
}

#[cfg(feature = "semantic-policy")]
struct PolicyStorage {
    buffers: PolicyBuffers,
    text_binding: Arc<TextBindingStorage>,
    _policy_witness: Option<SemanticTensorContentWitness>,
    replacement: Option<PolicyReplacement>,
    tape_live: bool,
    temporal_vjp_recorded: BTreeSet<(u64, usize)>,
}

/// Original policy snapshots awaiting the same parent's continuation. This
/// owner is not executable and survives failed continuation handoffs.
#[cfg(feature = "semantic-policy")]
struct PendingPolicyStorage {
    buffers: PolicyBuffers,
    replacement: PolicyReplacement,
    witness: Option<(SemanticTensorContentWitness, u64)>,
    invocation: SemanticRngBinding,
}

#[cfg(feature = "semantic-policy")]
impl std::ops::Deref for PolicyStorage {
    type Target = PolicyBuffers;
    fn deref(&self) -> &Self::Target {
        &self.buffers
    }
}

#[cfg(feature = "semantic-policy")]
struct PolicyProducerViews {
    text_logits: DeviceMemoryView<f32>,
    product_support: DeviceMemoryView<u8>,
    parameters: DeviceMemoryView<f32>,
    component_baselines: DeviceMemoryView<f32>,
    numerical: [DeviceMemoryView<f64>; 5],
}

#[cfg(feature = "semantic-policy")]
fn policy_source_views(
    originals: &[PreparedSemanticTensor],
) -> Result<PolicyProducerViews, SemanticTransitionError> {
    if originals.len() != 9 {
        return Err(publication_input_error(
            "policy requires its complete original producer roster",
        ));
    }
    let source = |index: usize| {
        originals[index]
            .source
            .clone()
            .ok_or_else(|| publication_input_error("policy producer storage is empty"))
    };
    // SAFETY: policy_producer_layouts and the original witness established
    // contiguous F32 shape, byte extents and alignment before this conversion.
    let text_logits = unsafe { source(0)?.cast::<f32>() }.ok_or_else(|| {
        publication_input_error("original text logits are not aligned F32 storage")
    })?;
    // SAFETY: the same typed original admission holds for model parameters.
    let parameters = unsafe { source(2)?.cast::<f32>() }.ok_or_else(|| {
        publication_input_error("original policy parameters are not aligned F32 storage")
    })?;
    // SAFETY: the fourth admitted producer is the exact rank-two FP32
    // component-baseline row issued by the original model invocation.
    let component_baselines = unsafe { source(3)?.cast::<f32>() }.ok_or_else(|| {
        publication_input_error("original component baselines are not aligned F32 storage")
    })?;
    let mut numerical = Vec::with_capacity(5);
    for index in 4..9 {
        // SAFETY: the original F64 layout/witness proves alignment and extent.
        numerical.push(unsafe { source(index)?.cast::<f64>() }.ok_or_else(|| {
            publication_input_error("original policy numerical view is not aligned F64 storage")
        })?);
    }
    Ok(PolicyProducerViews {
        text_logits,
        product_support: source(1)?,
        parameters,
        component_baselines,
        numerical: numerical
            .try_into()
            .unwrap_or_else(|_| unreachable!("five numerical producers")),
    })
}

#[cfg(feature = "semantic-policy")]
fn enqueue_policy_snapshots(
    domain: &ResidentExecutionDomain,
    poisoned: &mut bool,
    buffers: &PolicyBuffers,
    support: &TrackedCudaSlice<u8>,
    original: &PolicyProducerViews,
) -> Result<(), SemanticTransitionError> {
    if original.text_logits.len() != buffers.text_logits.len()
        || original.product_support.len() != support.len()
        || original.parameters.len() != buffers.parameters.len()
        || original.component_baselines.len() != buffers.component_baselines.len()
    {
        return Err(publication_input_error(
            "original policy producers differ from their fixed native capacities",
        ));
    }
    let numerical_destinations = &buffers.numerical.buffers()[..5];
    if numerical_destinations
        .iter()
        .zip(&original.numerical)
        .any(|(destination, source)| destination.len() != source.len())
    {
        return Err(publication_input_error(
            "original numerical policy capacities differ",
        ));
    }
    let mut recorder = domain.new_strict_recorder();
    recorder.read(&original.text_logits);
    recorder.read(&original.product_support);
    recorder.read(&original.parameters);
    recorder.read(&original.component_baselines);
    recorder.write(&buffers.text_logits);
    recorder.write(support);
    recorder.write(&buffers.parameters);
    recorder.write(&buffers.component_baselines);
    for (destination, source) in numerical_destinations.iter().zip(&original.numerical) {
        recorder.read(source);
        recorder.write(*destination);
    }
    enqueue_recorded(domain, poisoned, recorder, |enqueue| {
        for (destination, source, bytes) in [
            (
                buffers.text_logits.device_ptr_value(),
                *original.text_logits.device_ptr(),
                original.text_logits.len() * 4,
            ),
            (
                support.device_ptr_value(),
                *original.product_support.device_ptr(),
                original.product_support.len(),
            ),
            (
                buffers.parameters.device_ptr_value(),
                *original.parameters.device_ptr(),
                original.parameters.len() * 4,
            ),
            (
                buffers.component_baselines.device_ptr_value(),
                *original.component_baselines.device_ptr(),
                original.component_baselines.len() * 4,
            ),
        ] {
            // SAFETY: fixed typed capacities bound each original source and
            // distinct retained destination; this performs only device copies.
            unsafe {
                sys::cuMemcpyDtoDAsync_v2(destination, source, bytes, enqueue.stream().cu_stream())
            }
            .result()
            .map_err(|error| XlogError::Kernel(error.to_string()))?;
        }
        for (destination, source) in numerical_destinations.iter().zip(&original.numerical) {
            // SAFETY: matching F64 original/retained extents are disjoint.
            unsafe {
                sys::cuMemcpyDtoDAsync_v2(
                    destination.device_ptr_value(),
                    *source.device_ptr(),
                    source.len() * 8,
                    enqueue.stream().cu_stream(),
                )
            }
            .result()
            .map_err(|error| XlogError::Kernel(error.to_string()))?;
        }
        Ok::<(), XlogError>(())
    })
}

#[cfg(feature = "semantic-policy")]
struct PolicyReplacement {
    support: TrackedCudaSlice<u8>,
    receipts: TrackedCudaSlice<SemanticTransitionReceipt>,
    state: TrackedCudaSlice<DeviceState>,
}

/// Original numerical inputs and receipts survive later publication and rebinding.
/// Backward consumes this exact invocation once, independently of the current bank.
#[cfg(feature = "semantic-policy")]
struct PolicyTape {
    invocation: SemanticRngBinding,
    refusal: Option<SemanticTransitionRefusal>,
    binding: SemanticCatalogueBinding,
    policy: PolicyStorage,
    support: TrackedCudaSlice<u8>,
    receipts: TrackedCudaSlice<SemanticTransitionReceipt>,
    prepared_bank: Option<usize>,
    // Ordinary proposals keep the exact device state observed with this tape;
    // later restored invocations may rebind the Session's working state.
    origin_state: Option<TrackedCudaSlice<DeviceState>>,
    // Immutable cold catalogue allocations remain shared by their original
    // invocation tapes; no later binding overwrites their bytes.
    components: DeviceMemoryView<SemanticComponent>,
    codebooks: DeviceMemoryView<u64>,
}

#[cfg(feature = "semantic-policy")]
struct PolicyVjpRecording {
    descriptor: Descriptor,
    recorder: LaunchRecorder,
}

#[cfg(feature = "semantic-policy")]
#[derive(Clone, Copy)]
enum PolicyVjpInput<'a> {
    External(&'a DeviceMemoryView<f64>),
    UpdateObjective {
        training: &'a SemanticSelectedTrainingView,
        origin_candidate: u64,
        origin_lease: &'a TrackedCudaSlice<PublicationLease>,
        origin_bank: usize,
    },
    GroupMember {
        training: &'a SemanticSelectedTrainingView,
        member_ordinal: u64,
        origin_candidate: u64,
        origin_lease: &'a TrackedCudaSlice<PublicationLease>,
        origin_bank: usize,
        critic_term: &'a DeviceMemoryView<f32>,
    },
    EditMember {
        training: &'a SemanticSelectedTrainingView,
        member_ordinal: u64,
        origin_candidate: u64,
        origin_lease: &'a TrackedCudaSlice<PublicationLease>,
        origin_bank: usize,
    },
}

impl crate::cuda_compat::KernelParamStorage for Descriptor {
    fn as_kernel_param(&self) -> *mut std::ffi::c_void {
        (self as *const Self).cast_mut().cast()
    }
}
impl crate::cuda_compat::IntoKernelParamStorage for Descriptor {
    type Storage = Self;
    fn into_kernel_param_storage(self) -> Self {
        self
    }
}

macro_rules! content_kernel_parameter {
    ($ty:ty) => {
        impl crate::cuda_compat::KernelParamStorage for $ty {
            fn as_kernel_param(&self) -> *mut std::ffi::c_void {
                (self as *const Self).cast_mut().cast()
            }
        }
        impl crate::cuda_compat::IntoKernelParamStorage for $ty {
            type Storage = Self;
            fn into_kernel_param_storage(self) -> Self {
                self
            }
        }
    };
}
content_kernel_parameter!(PublicationRange);
content_kernel_parameter!(SemanticTensorLayout);
content_kernel_parameter!(ContinuationInputs);
content_kernel_parameter!(PolicyDescriptor);
content_kernel_parameter!(prepared_replay::ReplayCopyDescriptor);
content_kernel_parameter!(learning_phase::FoldDeviceAssignment);
#[cfg(feature = "semantic-policy")]
content_kernel_parameter!(PolicyUniformDescriptor);

const _: () = assert!(size_of::<PendingContinuation>() == 344);
const _: () = assert!(size_of::<ContinuationInputs>() == 208);
const _: () = assert!(size_of::<SemanticTransitionReceipt>() == 296);
const _: () = assert!(size_of::<SemanticTaskFacts>() == 88);
const _: () = assert!(size_of::<DeviceTaskEvaluation>() == 3328);
const _: () = assert!(size_of::<DeviceState>() == 7568);
const _: () = assert!(size_of::<PolicyField>() == 32);
const _: () = assert!(size_of::<PolicyNumericalDescriptor>() == 96);
const _: () = assert!(size_of::<PolicyUniformDescriptor>() == 160);
const _: () = assert!(size_of::<PolicyAdjointNumericalDescriptor>() == 96);
const _: () = assert!(size_of::<PolicyDescriptor>() == 776);
const _: () = assert!(size_of::<PolicyBackward>() == 256);
const _: () = assert!(size_of::<Descriptor>() == 1368);
const OBSERVATION_BYTES: usize =
    size_of::<DeviceState>() + COMPONENT_COUNT * size_of::<SemanticTransitionReceipt>();

#[cfg(test)]
mod task_state_contract {
    use super::*;

    #[test]
    fn text_null_requires_the_complete_singleton_receipt() {
        let mut receipt = SemanticTransitionReceipt {
            kind: COMPONENT_KIND_TEXT as u32,
            choice: TEXT_NULL as u32,
            legal_count: 1,
            active_count: 1,
            p: [1, 0, 0],
            q: [1, 0, 0],
            factor_denominator: [1, 0, 0],
            cdf_end: 1 << 63,
            mass: 1 << 63,
            ..SemanticTransitionReceipt::default()
        };
        assert!(canonical_text_null(&receipt));
        let exact = receipt;
        receipt.choice = 0;
        assert!(!canonical_text_null(&receipt));
        receipt = exact;
        receipt.p[1] = 1;
        assert!(!canonical_text_null(&receipt));
        receipt = exact;
        receipt.cdf_start = 1;
        assert!(!canonical_text_null(&receipt));
        receipt = exact;
        receipt.active_count = 2;
        assert!(!canonical_text_null(&receipt));
        receipt = exact;
        receipt.mass -= 1;
        assert!(!canonical_text_null(&receipt));
    }

    #[test]
    fn task_state_bank_includes_actual_query_receipts() {
        assert_eq!(size_of::<DeviceState>(), 7568);
        assert_eq!(size_of::<Descriptor>(), 1368);
    }

    #[test]
    fn ordinary_refusal_requires_original_coordinates_and_completed_cleanup() {
        let rng = SemanticRngBinding {
            model_generation: 3,
            family_id: 4,
            stream_serial: 5,
            proposal: 6,
        };
        let binding = SemanticActionCatalogue::current().binding();
        let original = DeviceState {
            model_generation: rng.model_generation,
            family_id: u32::from(rng.family_id),
            stream_serial: rng.stream_serial,
            proposal: 6,
            next_proposal: 6,
            catalogue_generation: binding.generation,
            catalogue_digest: binding.digest,
            binding_digest: binding.digest,
            status: 5,
            ..DeviceState::default()
        };
        assert_eq!(
            refused_terminal(&original, rng, binding, binding.digest, None).unwrap(),
            SemanticTransitionRefusal::NonFinitePolicyInput { completed_draws: 0 }
        );
        for mutation in 0..8 {
            let mut state = original;
            match mutation {
                0 => state.model_generation += 1,
                1 => state.family_id += 1,
                2 => state.stream_serial += 1,
                3 => state.next_proposal += 1,
                4 => state.blocks = COMPONENT_COUNT as u64,
                5 => state.importance_weight = 1.0,
                6 => state.cleanup_receipts[0][0] = 1,
                _ => state.retired_roots_mask = 4,
            }
            assert!(refused_terminal(&state, rng, binding, binding.digest, None).is_err());
        }
        for status in [0, 1, 3, 4, 6, 7, 8, 9, 10] {
            let mut state = original;
            state.status = status;
            assert!(refused_terminal(&state, rng, binding, binding.digest, None).is_err());
        }
        let mut state = original;
        state.status = 2;
        state.blocks = 50;
        assert_eq!(
            refused_terminal(&state, rng, binding, binding.digest, None).unwrap(),
            SemanticTransitionRefusal::InvalidFinalSupport {
                completed_draws: 50
            }
        );
        state.status = 11;
        assert!(refused_terminal(&state, rng, binding, binding.digest, None).is_err());
        state.execution_work.overflow = 1;
        assert_eq!(
            refused_terminal(&state, rng, binding, binding.digest, None).unwrap(),
            SemanticTransitionRefusal::WorkCounterOverflow {
                completed_draws: 50
            }
        );
        state.next_proposal += 1;
        assert!(refused_terminal(&state, rng, binding, binding.digest, None).is_err());
    }

    #[test]
    fn refused_seal_cleanup_distinguishes_aliases_from_retired_private_roots() {
        let mut state = DeviceState::default();
        assert!(refused_root_cleanup(&state, 17, 2, 3).is_ok());
        state.semantic_receipts[3][33] = 1;
        state.semantic_receipts[3][39] = 17;
        state.semantic_receipts[3][1] = 2;
        state.semantic_receipts[3][34] = 2;
        state.semantic_receipts[3][35] = 3;
        assert!(refused_root_cleanup(&state, 17, 2, 3).is_err());
        state.retired_roots_mask = 1;
        assert!(refused_root_cleanup(&state, 17, 2, 3).is_ok());
        state.cleanup_receipts[1][39] = 17;
        assert!(
            refused_root_cleanup(&state, 17, 2, 3).is_err(),
            "base aliases are never retired"
        );
        state.semantic_receipts[3][1] = 1;
        state.semantic_receipts[3][34] = 7;
        state.cleanup_receipts[1][3] = 7;
        state.cleanup_receipts[1][4] = 4;
        assert!(refused_root_cleanup(&state, 17, 2, 3).is_ok());
        state.cleanup_receipts[1][4] = 3;
        assert!(refused_root_cleanup(&state, 17, 2, 3).is_err());
        state.cleanup_receipts[1][4] = 4;
        state.retired_roots_mask = 3;
        assert!(
            refused_root_cleanup(&state, 17, 2, 3).is_err(),
            "no seal exists in the other lane"
        );
    }
}

/// Completed device outcome. A refusal carries no successor, selected-score
/// receipts, or derivative authority; it is not a successful observation.
#[derive(Clone, Debug, PartialEq)]
#[expect(
    clippy::large_enum_variant,
    reason = "published outcomes retain the original invocation owner without another allocation"
)]
pub enum SemanticTransitionOutcome {
    Published(SemanticTransitionObservation),
    Refused(SemanticTransitionRefusal),
}

impl SemanticTransitionOutcome {
    /// Inspect the original result without relinquishing its invocation owner.
    /// A refusal preserves the same typed error as consuming the outcome.
    pub fn as_published(&self) -> Result<&SemanticTransitionObservation, SemanticTransitionError> {
        match self {
            Self::Published(observation) => Ok(observation),
            Self::Refused(refusal) => Err(refusal.into_error()),
        }
    }

    pub fn into_published(self) -> Result<SemanticTransitionObservation, SemanticTransitionError> {
        match self {
            Self::Published(observation) => Ok(observation),
            Self::Refused(refusal) => Err(refusal.into_error()),
        }
    }
}

/// Ordinary device refusal after authentic parent and cleanup reconciliation.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SemanticTransitionRefusal {
    InvalidFinalSupport {
        completed_draws: u64,
    },
    NonFinitePolicyInput {
        completed_draws: u64,
    },
    WorkCounterOverflow {
        completed_draws: u64,
    },
    InvalidTrainingView {
        status: u64,
    },
    RejectedModelUpdate {
        evidence: SemanticTrainingCanaryRefusalRecord,
    },
}

impl SemanticTransitionRefusal {
    fn into_error(self) -> SemanticTransitionError {
        match self {
            Self::InvalidFinalSupport { completed_draws } => {
                SemanticTransitionError::InvalidFinalSupport { completed_draws }
            }
            Self::NonFinitePolicyInput { completed_draws } => {
                SemanticTransitionError::NonFinitePolicyInput { completed_draws }
            }
            Self::WorkCounterOverflow { completed_draws } => {
                SemanticTransitionError::WorkCounterOverflow { completed_draws }
            }
            Self::InvalidTrainingView { status } => {
                SemanticTransitionError::InvalidTrainingView { status }
            }
            Self::RejectedModelUpdate { evidence } => {
                SemanticTransitionError::RejectedModelUpdate {
                    evidence: Box::new(evidence),
                }
            }
        }
    }
}

#[cfg(feature = "semantic-policy")]
fn decode_canary_refusal(
    record: SemanticTrainingCanaryRefusalRecord,
    results: &[SemanticTrainingCanaryResultRecord],
) -> Result<Option<SemanticTrainingCanaryRefusalRecord>, SemanticTransitionError> {
    if record.abi != 1 {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    if record.reason == 0 {
        let success = SemanticTrainingCanaryRefusalRecord {
            abi: 1,
            ..SemanticTrainingCanaryRefusalRecord::default()
        };
        return (record == success)
            .then_some(None)
            .ok_or(SemanticTransitionError::ObservationMismatch);
    }
    let reason = record
        .reason()
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    let original = results
        .iter()
        .find(|result| result.kind == record.kind)
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
    if original.abi != 1
        || original.availability > 2
        || original.reason != record.reason
        || original.row_ordinal != record.row_ordinal
        || original.identity != record.identity
        || original.measurement_bits != record.measurement_bits
        || original.memory_used != record.memory_used
        || original.work_used != record.work_used
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    let lower = f64::from_bits(record.lower_bound_bits);
    let upper = f64::from_bits(record.upper_bound_bits);
    let measurement = f64::from_bits(record.measurement_bits);
    if !(1..=5).contains(&record.kind)
        || !lower.is_finite()
        || !upper.is_finite()
        || lower > upper
        || record.memory_limit == 0
        || record.work_limit == 0
        || (original.availability == 2
            && match reason {
                SemanticTrainingCanaryRefusalReason::NonFiniteMeasurement => {
                    measurement.is_finite()
                }
                SemanticTrainingCanaryRefusalReason::OutsideBounds => {
                    !measurement.is_finite() || (measurement >= lower && measurement <= upper)
                }
                SemanticTrainingCanaryRefusalReason::MemoryLimitExceeded => {
                    !measurement.is_finite()
                        || measurement < lower
                        || measurement > upper
                        || record.memory_used <= record.memory_limit
                }
                SemanticTrainingCanaryRefusalReason::WorkLimitExceeded => {
                    // The final work-limit pass can outrank an earlier retention
                    // or goal refusal, which skipped bounds and memory checks.
                    // Its original result therefore proves only this limit.
                    record.work_used <= record.work_limit
                }
                SemanticTrainingCanaryRefusalReason::IncompleteOperands
                | SemanticTrainingCanaryRefusalReason::ProtectedRetentionLost
                | SemanticTrainingCanaryRefusalReason::GoalWitnessInvalid
                | SemanticTrainingCanaryRefusalReason::WorkOverflow
                | SemanticTrainingCanaryRefusalReason::GenerationMismatch => false,
            })
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    Ok(Some(record))
}

fn refused_terminal(
    state: &DeviceState,
    rng: SemanticRngBinding,
    catalogue: SemanticCatalogueBinding,
    binding_digest: Identity256,
    canary_refusal: Option<SemanticTrainingCanaryRefusalRecord>,
) -> Result<SemanticTransitionRefusal, SemanticTransitionError> {
    if state.model_generation != rng.model_generation
        || state.family_id != u32::from(rng.family_id)
        || state.stream_serial != rng.stream_serial
        || state.proposal != u64::from(rng.proposal)
        || state.next_proposal != state.proposal
        || state.blocks >= COMPONENT_COUNT as u64
        || state.catalogue_generation != catalogue.generation
        || state.catalogue_digest != catalogue.digest
        || state.binding_digest != binding_digest
        || state.importance_weight != 0.0
        || state.retired_roots_mask & !3 != 0
        || state.cleanup_receipts.iter().any(|receipt| receipt[0] != 0)
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    match state.status {
        2 => Ok(SemanticTransitionRefusal::InvalidFinalSupport {
            completed_draws: state.blocks,
        }),
        5 => Ok(SemanticTransitionRefusal::NonFinitePolicyInput {
            completed_draws: state.blocks,
        }),
        11 if state.execution_work.overflow == 1 => {
            Ok(SemanticTransitionRefusal::WorkCounterOverflow {
                completed_draws: state.blocks,
            })
        }
        12..=14 if state.execution_work.overflow == 0 && state.blocks == 0 => {
            Ok(SemanticTransitionRefusal::InvalidTrainingView {
                status: state.status - 11,
            })
        }
        15 if state.execution_work.overflow == 0 && state.blocks == 0 => {
            Ok(SemanticTransitionRefusal::RejectedModelUpdate {
                evidence: canary_refusal.ok_or(SemanticTransitionError::ObservationMismatch)?,
            })
        }
        _ => Err(SemanticTransitionError::ObservationMismatch),
    }
}

fn refused_root_cleanup(
    state: &DeviceState,
    owner: u64,
    base_slot: u64,
    base_generation: u64,
) -> Result<(), SemanticTransitionError> {
    let mismatch = || SemanticTransitionError::ObservationMismatch;
    // This slot may describe either the inactive root retired by publication
    // admission or a later candidate discard. The completed kernel checks the
    // corresponding owner operation and changes status to failure on error.
    let cleanup = &state.cleanup_receipts[0];
    if cleanup.iter().any(|&word| word != 0) && (cleanup[0] != 0 || cleanup[39] != owner) {
        return Err(mismatch());
    }
    for lane in 0..2 {
        let sealed = &state.semantic_receipts[3 + lane * 3];
        let cleanup = &state.cleanup_receipts[1 + lane];
        let consumed = state.retired_roots_mask & (1 << lane) != 0;
        // Resident root-kind is 1; a cleared or failed seal owns no sealed root.
        if sealed[0] != 0 || sealed[33] != 1 {
            if consumed || cleanup.iter().any(|&word| word != 0) {
                return Err(mismatch());
            }
            continue;
        }
        if !consumed || sealed[39] != owner {
            return Err(mismatch());
        }
        match sealed[1] {
            // An unchanged seal only aliases the protected base, so there is
            // deliberately no retirement receipt for it.
            2 if sealed[34] == base_slot
                && sealed[35] == base_generation
                && cleanup.iter().all(|&word| word == 0) => {}
            1 if cleanup[0] == 0
                && cleanup[1] == 0
                && cleanup[39] == owner
                && cleanup[3] == sealed[34]
                && sealed[35].checked_add(1) == Some(cleanup[4]) => {}
            _ => return Err(mismatch()),
        }
    }
    Ok(())
}

#[derive(Clone, Debug, PartialEq)]
pub struct SemanticTransitionObservation {
    pub components: Vec<SemanticTransitionReceipt>,
    pub root_handle: SemanticRootHandle,
    pub root: SemanticRootSnapshot,
    pub next_proposal: u64,
    pub lanes: [SemanticTransitionLane; 2],
    /// Full device-computed FP64 importance weight in original component order.
    /// The receipts retain the exact rational factors; this rounded reduction
    /// neither replaces them nor certifies the downstream parameter gradient.
    pub importance_weight: f64,
    /// Present only for the separately cold-bound finite evaluator.
    pub task_evaluation: Option<SemanticTaskEvaluation>,
}

/// A task-local refusal is not a semantic infrastructure failure.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SemanticTaskRefusal {
    Scope,
    HardConstraint,
    FactCapacity,
    FuelExhausted,
}

impl SemanticTaskRefusal {
    pub const fn canonical_kind(self) -> &'static str {
        match self {
            Self::Scope => "task-scope",
            Self::HardConstraint => "hard-constraint",
            Self::FactCapacity => "fact-capacity",
            Self::FuelExhausted => "fuel-exhausted",
        }
    }
}

/// One native evaluation of the fixed base/learned roster. The selector runs
/// only on device; these are the resulting facts, not caller-supplied scores.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticTaskEvaluation {
    pub binding: Identity256,
    pub query_count: u64,
    pub winner: u64,
    pub return_value: i64,
    pub facts: [SemanticTaskFacts; 3],
}

/// Device terminal and both ordered edit results. A refused lane has no root;
/// successful edit receipts preceding rollback are not published graph state.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SemanticTransitionLane {
    /// No sealed root is produced for a task-local refusal. An owner refusal
    /// remains an actual owner error, distinct from an evaluator decision.
    pub root: Option<Result<(SemanticRootHandle, SemanticRootSnapshot), SemanticHypergraphError>>,
    pub task_refusal: Option<SemanticTaskRefusal>,
    /// Decoded binary rules attempted in the two edit slots, including a lane
    /// later rejected by a hard constraint. Graph support edits remain in `edits`.
    pub program_rules: [Option<crate::SemanticProgramRule>; 2],
    pub edits: [Result<Option<SemanticInsertOutcome>, SemanticHypergraphError>; 2],
    /// Actual owner work, retained even when the candidate is discarded.
    pub work: SemanticTransitionWork,
}

/// Work performed by the two semantic edits of one learned candidate. These are
/// device counters, not estimates from the sampled actions or final truth alone.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SemanticTransitionWork {
    /// Calls to the modifying semantic owner, including a call that refuses.
    /// A NO_EDIT or a suppressed edit does not call that owner.
    pub edit_commands: u64,
    /// New reachable support attachments, or new materialized facts for an
    /// editable program, made before any candidate discard.
    pub added_supports: u64,
    /// Successful support edits that change a truth other than NEITHER, or
    /// changed query truths after program materialization.
    pub defined_truth_changes: u64,
}

impl SemanticTransitionWork {
    #[cfg(any(test, feature = "semantic-policy"))]
    fn raw_structural_cost(self) -> u64 {
        self.edit_commands + self.added_supports + self.defined_truth_changes
    }

    fn is_valid(self, editable_program: bool) -> bool {
        if self.edit_commands > 2 {
            return false;
        }
        if editable_program {
            self.added_supports <= crate::semantic_program::RESIDENT_PROGRAM_FACT_CAPACITY as u64
                && self.defined_truth_changes <= 3
                && (self.edit_commands != 0
                    || (self.added_supports == 0 && self.defined_truth_changes == 0))
        } else {
            self.added_supports <= self.edit_commands
                && self.defined_truth_changes <= self.added_supports
        }
    }
}

/// Provider counters and explicit session stream waits. Compare snapshots around
/// launch only: cold binding/capture and terminal observation are outside it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticTransitionHostIoStats {
    pub htod_bytes: u64,
    pub dtoh_bytes: u64,
    pub htod_calls: u64,
    pub dtoh_calls: u64,
    pub launch_metadata_bytes: u64,
    pub launch_metadata_calls: u64,
    pub metadata_dtoh_calls: u64,
    pub observation_bytes: u64,
    pub observation_calls: u64,
    pub session_stream_waits: u64,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SemanticTransitionError {
    CatalogueMismatch,
    InvalidInput {
        detail: String,
    },
    InvalidFinalSupport {
        completed_draws: u64,
    },
    NonFinitePolicyInput {
        completed_draws: u64,
    },
    WorkCounterOverflow {
        completed_draws: u64,
    },
    InvalidPolicyGradient {
        status: u64,
    },
    InvalidTrainingView {
        status: u64,
    },
    RejectedModelUpdate {
        evidence: Box<SemanticTrainingCanaryRefusalRecord>,
    },
    InvalidTaskBank,
    InvalidTaskBase,
    TaskOwnerFailure,
    PublicationRefused {
        status: u64,
    },
    OverlappingInputs,
    OverlappingLaunch,
    UnconsumedPolicyTape,
    UnpublishedTask,
    NotBound,
    NotCaptured,
    NoPendingLaunch,
    GenerationExhausted,
    ObservationMismatch,
    Poisoned,
    Semantic(SemanticHypergraphError),
    Runtime {
        operation: &'static str,
        detail: String,
    },
}

impl fmt::Display for SemanticTransitionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}
impl std::error::Error for SemanticTransitionError {}

fn runtime_error(operation: &'static str, error: impl fmt::Display) -> SemanticTransitionError {
    SemanticTransitionError::Runtime {
        operation,
        detail: error.to_string(),
    }
}

/// Pinned terminal bank, allocated before capture, never used for hot-loop metadata.
struct PinnedObservation {
    buffer: crate::device::PinnedHostBuffer,
}

impl PinnedObservation {
    fn new(stream: Arc<CudaStream>) -> Result<Self, SemanticTransitionError> {
        Ok(Self {
            buffer: crate::device::PinnedHostBuffer::new(&stream, OBSERVATION_BYTES)
                .map_err(|error| runtime_error("pinned observation allocation", error))?,
        })
    }

    fn enqueue_copy(&mut self, state: u64, receipts: u64, stream: &CudaStream) -> XlogResult<()> {
        // SAFETY: the recorder admits both fixed-size device ranges. The shared
        // pinned owner retains this whole batch, including a partially failed copy.
        unsafe {
            self.buffer.enqueue(stream, |ptr| {
                for (offset, source, len) in [
                    (0, state, size_of::<DeviceState>()),
                    (
                        size_of::<DeviceState>(),
                        receipts,
                        OBSERVATION_BYTES - size_of::<DeviceState>(),
                    ),
                ] {
                    // SAFETY: fixed-size ranges belong to this pinned bank and live device
                    // owners. Session waits before reading or freeing either allocation.
                    let code = {
                        sys::cuMemcpyDtoHAsync_v2(
                            ptr.add(offset).cast(),
                            source,
                            len,
                            stream.cu_stream(),
                        )
                    };
                    code.result()?;
                }
                Ok(())
            })
        }
        .map_err(|error| XlogError::Kernel(format!("semantic final observation copy: {error}")))
    }

    /// Caller must have completed the stream wait after both copies.
    unsafe fn read(
        &mut self,
    ) -> Result<(DeviceState, Vec<SemanticTransitionReceipt>), SemanticTransitionError> {
        // SAFETY: both fixed-size copies initialized the complete byte bank.
        let bytes = unsafe { self.buffer.read_vec::<u8>(OBSERVATION_BYTES) }
            .map_err(|error| runtime_error("pinned observation read", error))?;
        // SAFETY: caller establishes completion; allocations and integral ABI sizes
        // are checked, and unaligned reads do not require additional host alignment.
        let state = unsafe { bytes.as_ptr().cast::<DeviceState>().read_unaligned() };
        let components = (0..COMPONENT_COUNT)
            .map(|i| unsafe {
                bytes
                    .as_ptr()
                    .add(size_of::<DeviceState>() + i * size_of::<SemanticTransitionReceipt>())
                    .cast::<SemanticTransitionReceipt>()
                    .read_unaligned()
            })
            .collect();
        Ok((state, components))
    }
}

/// Single owner of one serial transition stream, graph, scratch, and receipt bank.
/// Retains the provider independently of the caller's handle.
pub struct SemanticTransitionSession {
    // Drop waits before destroying the exec, then retires its device storage.
    captured: Option<CapturedCudaGraph>,
    domain: ResidentExecutionDomain,
    stream: Arc<CudaStream>,
    graph: std::mem::ManuallyDrop<SemanticHypergraph>,
    root: SemanticRootHandle,
    base_snapshot: SemanticRootSnapshot,
    codebooks: ActionCodebooks,
    device_codebooks: TrackedCudaSlice<u64>,
    device_components: TrackedCudaSlice<SemanticComponent>,
    // Private observer/checker results never enter the proposal codebooks.
    task: Option<(TaskEvaluationBinding, TrackedCudaSlice<u64>)>,
    // A cold read can precede the final observed-source/authority import. The
    // later binding must reproduce this exact executed task content.
    cold_content: Option<(SemanticTaskContentIdentity, [crate::SemanticTruth; 3])>,
    initial_prefill: Option<InitialPrefillStage>,
    retained_initial_prefill: Option<RetainedInitialPrefillContent>,
    checkpoint_initial_prefill: Option<CheckpointInitialPrefill>,
    training_views: Option<Arc<SemanticTrainingViewArena>>,
    training_origins: Option<Arc<TrackedCudaSlice<SemanticTrainingViewOriginRecord>>>,
    task_epoch: u64,
    // Terminal observation does not publish a world. Keep the chosen roots and
    // raw banks immutable until the joint publisher consumes this pending tuple.
    task_observed: bool,
    publication: Option<Arc<PublicationStorage>>,
    learning_phases: Vec<SemanticLearningPhaseRecord>,
    publication_uploads: Vec<(usize, PublicationPayload)>,
    publication_issuer: Arc<()>,
    readers: BTreeMap<u64, PublishedReader>,
    steps: BTreeMap<u64, StepContentStorage>,
    prepared_segment: Option<PreparedSegmentState>,
    prepared_resources: Vec<Arc<dyn Send + Sync>>,
    next_reader: u64,
    continuation_base: Option<u64>,
    text_binding: Option<Arc<TextBindingStorage>>,
    admitted_transition: Option<(u64, u64, SemanticTransitionKind)>,
    release_events: Vec<cudarc::driver::CudaEvent>,
    logits: TrackedCudaSlice<f32>,
    support: TrackedCudaSlice<u8>,
    scratch: TrackedCudaSlice<u64>,
    receipts: TrackedCudaSlice<SemanticTransitionReceipt>,
    state: TrackedCudaSlice<DeviceState>,
    pinned: PinnedObservation,
    execute: CudaFunction,
    #[cfg(feature = "semantic-policy")]
    policy: Option<PolicyStorage>,
    #[cfg(feature = "semantic-policy")]
    pending_policy: Option<PendingPolicyStorage>,
    #[cfg(feature = "semantic-policy")]
    policy_tapes: Vec<PolicyTape>,
    rng: Option<SemanticRngBinding>,
    next_proposal: u64,
    pending: bool,
    poisoned: bool,
    stream_waits: u64,
    // All captured work and storage retire before their driver/allocation owner.
    provider: Arc<CudaKernelProvider>,
}

/// Results retain each actual device invocation. An early admission refusal
/// owns no numerical invocation, selected receipts, or derivative authority.
/// Intermediate root records are historical receipts; a later step may retire
/// their slots. Acquire the canonical final reader for the current publication.
#[derive(Clone, Debug)]
#[expect(
    clippy::large_enum_variant,
    reason = "completed outcomes retain their original invocation and step owners"
)]
pub enum SemanticPreparedStepOutcome {
    Skipped {
        step: SemanticPreparedStep,
        status: u64,
    },
    Completed {
        step: SemanticPreparedStep,
        invocation: SemanticRngBinding,
        bank: u8,
        transition: SemanticTransitionKind,
        outcome: SemanticTransitionOutcome,
    },
}

const _: () = assert!(
    size_of::<PreparedStepResult>()
        == size_of::<PublicationHeader>() + 32 + size_of::<AttemptReceipt>()
);

fn prepared_step_allocation_bytes(
    input_bytes: usize,
    feedback_bytes: usize,
    policy_bytes: usize,
) -> Result<u64, SemanticTransitionError> {
    [
        size_of::<PublicationLease>(),
        size_of::<PreparedStepResult>(),
        input_bytes,
        feedback_bytes,
        policy_bytes,
    ]
    .into_iter()
    .try_fold(0usize, |sum, bytes| {
        sum.checked_add(bytes)
            .ok_or(SemanticTransitionError::GenerationExhausted)
    })
    .and_then(|bytes| {
        u64::try_from(bytes).map_err(|_| SemanticTransitionError::GenerationExhausted)
    })
}

fn prepared_segment_allocation_bytes(
    step_bytes: u64,
    transition_bound: usize,
    training_origin_bytes: usize,
) -> Result<u64, SemanticTransitionError> {
    if transition_bound == 0 {
        return Err(publication_input_error(
            "a prepared segment requires a positive transition bound",
        ));
    }
    u64::try_from(transition_bound)
        .ok()
        .and_then(|bound| step_bytes.checked_mul(bound))
        .and_then(|bytes| {
            u64::try_from(training_origin_bytes)
                .ok()
                .and_then(|origin_bytes| bytes.checked_add(origin_bytes))
        })
        .ok_or(SemanticTransitionError::GenerationExhausted)
}

/// Frozen bounds for the content, work, and external allocations currently
/// admitted during prepared-segment construction. Numerical-domain buffers
/// require their own native-derived extension before the full peak is claimed.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SemanticSegmentColdCapacity {
    pub tensor_content_capacity: usize,
    pub model_work_capacity: usize,
    pub segment_capacity_bytes: u64,
    pub other_external_cuda_bytes: u64,
}

impl SemanticSegmentColdCapacity {
    fn external_floor(self) -> Result<u64, SemanticTransitionError> {
        if self.tensor_content_capacity == 0
            || self.model_work_capacity == 0
            || self.segment_capacity_bytes == 0
        {
            return Err(publication_input_error(
                "prepared segment requires positive frozen native capacities and external slab bytes",
            ));
        }
        self.segment_capacity_bytes
            .checked_add(self.other_external_cuda_bytes)
            .ok_or(SemanticTransitionError::GenerationExhausted)
    }

    fn content_cells(self) -> Result<usize, SemanticTransitionError> {
        self.tensor_content_capacity
            .checked_mul(4)
            .ok_or(SemanticTransitionError::GenerationExhausted)
    }

    fn content_bytes(self) -> Result<u64, SemanticTransitionError> {
        self.content_cells()?
            .checked_mul(size_of::<u64>())
            .and_then(|bytes| u64::try_from(bytes).ok())
            .ok_or(SemanticTransitionError::GenerationExhausted)
    }

    fn model_work_bytes(self) -> Result<u64, SemanticTransitionError> {
        self.model_work_capacity
            .checked_mul(size_of::<ModelWorkEvent>() + 3 * size_of::<u64>())
            .and_then(|bytes| u64::try_from(bytes).ok())
            .ok_or(SemanticTransitionError::GenerationExhausted)
    }

    fn late_native_bytes(self, steps: usize) -> Result<u64, SemanticTransitionError> {
        self.content_bytes()?
            .checked_add(self.model_work_bytes()?)
            .and_then(|bytes| bytes.checked_mul(u64::try_from(steps).ok()?))
            .ok_or(SemanticTransitionError::GenerationExhausted)
    }
}

#[cfg(feature = "semantic-policy")]
fn policy_buffer_bytes(
    layout: &SemanticPolicyLayout,
    mask_cells: usize,
) -> Result<usize, SemanticTransitionError> {
    let differentiable_cells = [
        layout.parameter_cells,
        layout.score_cells(),
        layout.recurrent_cells(),
        32 * TEXT_CARDINALITY,
    ]
    .into_iter()
    .try_fold(0usize, |sum, cells| {
        sum.checked_add(cells)
            .ok_or(SemanticTransitionError::GenerationExhausted)
    })?;
    let primal_cells = differentiable_cells
        .checked_add(layout.retained_score_cells())
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let adjoint_cells = differentiable_cells
        .checked_add(COMPONENT_COUNT)
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let adjoint_cells = adjoint_cells
        .checked_mul(2)
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let numerical_cells = [
        // Original E/D plus explicitly assembled primal envelopes.
        (layout.parameter_cells, 9usize),
        (COMPONENT_COUNT, 9),
        (32 * TEXT_CARDINALITY, 4),
        (128, 3),
        (layout.score_cells(), 3),
        (layout.recurrent_cells(), 3),
    ]
    .into_iter()
    .try_fold(0usize, |total, (cells, width)| {
        cells
            .checked_mul(width)
            .and_then(|cells| total.checked_add(cells))
            .ok_or(SemanticTransitionError::GenerationExhausted)
    })?;
    let adjoint_numerical_cells = differentiable_cells
        .checked_add(COMPONENT_COUNT)
        .and_then(|cells| cells.checked_mul(8))
        .and_then(|cells| {
            layout
                .parameter_cells
                .checked_add(32 * TEXT_CARDINALITY)
                .and_then(|roots| roots.checked_add(COMPONENT_COUNT))
                // In addition to the internal coherent labels above, export
                // full E (two doubles) and actor/full D (eight doubles).
                .and_then(|roots| roots.checked_mul(10))
                .and_then(|roots| cells.checked_add(roots))
        })
        .and_then(|cells| cells.checked_add(8 * COMPONENT_COUNT))
        .and_then(|cells| cells.checked_mul(2))
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let numerical_cells = numerical_cells
        .checked_add(adjoint_numerical_cells)
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let uniform_cells = layout
        .parameter_cells
        .checked_add(COMPONENT_COUNT)
        .and_then(|cells| cells.checked_mul(2))
        // Every unknown mapped text row has the same category domain. Keep
        // one private row and the required 32-row region-major public output.
        .and_then(|cells| cells.checked_add(33 * TEXT_CARDINALITY))
        // Private coherent labels and distinct region-major export storage.
        .and_then(|cells| cells.checked_mul(8))
        .and_then(|cells| cells.checked_add(layout.recurrent_cells() * 12))
        .and_then(|cells| cells.checked_add(layout.score_cells() * 12))
        .and_then(|cells| cells.checked_add(128 * 4 + COMPONENT_COUNT * 8))
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    let numerical_cells = numerical_cells
        .checked_add(uniform_cells)
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
    primal_cells
        // Each differentiable primal bank has a dedicated adjoint bank. Only the
        // forward hidden vector is shared scratch. A second retained adjoint bank
        // is reserved for temporal Update capture; coefficients and status keep
        // their own types in both banks.
        .checked_add(adjoint_cells)
        .and_then(|cells| cells.checked_add(128))
        .and_then(|cells| cells.checked_add(COMPONENT_COUNT))
        .and_then(|cells| cells.checked_mul(size_of::<f32>()))
        .and_then(|bytes| bytes.checked_add(2 * COMPONENT_COUNT * size_of::<f64>()))
        .and_then(|bytes| bytes.checked_add(2 * size_of::<u64>()))
        .and_then(|bytes| {
            bytes.checked_add(12 * size_of::<u64>() + size_of::<PolicyUniformDescriptor>())
        })
        .and_then(|bytes| {
            numerical_cells
                .checked_mul(8)
                .and_then(|extra| bytes.checked_add(extra))
        })
        .and_then(|bytes| bytes.checked_add(COMPONENT_COUNT * size_of::<SemanticPolicyPwlCell>()))
        .and_then(|bytes| {
            bytes.checked_add(COMPONENT_COUNT * size_of::<SemanticPolicySelectedScoreVjp>())
        })
        .and_then(|bytes| {
            mask_cells
                .checked_mul(2)
                .and_then(|masks| bytes.checked_add(masks))
        })
        .ok_or(SemanticTransitionError::GenerationExhausted)
}

fn validate_rebinding_ownership(
    prepared_segment: Option<&PreparedSegmentState>,
    unreconciled_acquisition: bool,
) -> Result<(), SemanticTransitionError> {
    if prepared_segment.is_some() {
        return Err(publication_input_error(
            "a prepared segment still owns its executable and native resources",
        ));
    }
    if unreconciled_acquisition {
        return Err(publication_input_error(
            "an unreconciled acquisition still owns its native step",
        ));
    }
    Ok(())
}

fn validate_prepared_completion(
    lease: &PublicationLease,
    parent: &PublicationHeader,
    result: &PreparedStepResult,
    instance: Identity256,
) -> Result<SemanticTransitionKind, SemanticTransitionError> {
    if lease.abi != 1
        || lease.status != 0
        || lease.active != 0
        || lease.instance != instance
        || lease.bank > 1
        || lease.bank != lease.word & 1
        || lease.epoch != lease.word >> 1
        || parent.abi != 1
        || parent.instance != instance
        || parent.publication_word != lease.word
        || parent.sealed_epoch != lease.epoch
        || result.abi != 1
        || result.header.abi != 1
        || result.header.instance != instance
        || result.header.publication_word != result.word
        || result.header.sealed_epoch != result.word >> 1
        || result.advanced > 1
        || result.advanced != u64::from(result.word != lease.word && result.refusal == 0)
    {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    if result.word != lease.word {
        let epoch = lease
            .epoch
            .checked_add(1)
            .filter(|&epoch| epoch <= u64::MAX >> 1)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if result.word != (epoch << 1) | ((lease.word ^ 1) & 1)
            || result.header.base_word != lease.word
            || result.attempt.abi != 2
            || result.attempt.transition_kind != lease.transition_kind
            || result.attempt.instance != result.header.instance
            || result.attempt.base_word != lease.word
            || result.attempt.next_word != result.word
            || result.attempt.logical_digest != result.header.logical_digest
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
    } else if result.attempt != AttemptReceipt::default() {
        return Err(SemanticTransitionError::ObservationMismatch);
    }
    match lease.transition_kind {
        1 => Ok(SemanticTransitionKind::Proposal),
        2 => Ok(SemanticTransitionKind::Recompute),
        3 => Ok(SemanticTransitionKind::Drain),
        4 => Ok(SemanticTransitionKind::Update),
        _ => Err(SemanticTransitionError::ObservationMismatch),
    }
}

#[cfg(feature = "semantic-policy")]
impl SemanticTransitionSession {
    /// Submit this Session's complete graph once with the freshly validated
    /// canonical authority snapshot. The metadata upload precedes graph launch.
    pub fn launch_prepared_segment(
        &mut self,
        authority_decisions: Vec<u8>,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or(SemanticTransitionError::NotCaptured)?;
        if !build.finished
            || build.submitted
            || self.captured.is_none()
            || authority_decisions.is_empty()
        {
            return Err(publication_input_error(
                "prepared submission requires one unused graph and fresh canonical authority bytes",
            ));
        }
        for token in &build.tokens {
            let prepared = self
                .steps
                .get(token)
                .and_then(|step| step.prepared.as_ref())
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if prepared.transition_recorded != PREPARED_TRANSITION_BANKS
                || prepared.branches.iter().any(|branch| {
                    branch.continuation.as_ref().is_none_or(|continuation| {
                        continuation.inputs.authority_bytes != authority_decisions.len() as u64
                    })
                })
            {
                return Err(publication_input_error(
                    "fresh authority snapshot differs from the captured continuation byte extent",
                ));
            }
        }
        let authority = storage
            .continuation_templates
            .iter()
            .find(|range| range.role == 39 && range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let slot = usize::try_from(authority.storage_slot)
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let destination = storage
            .allocations
            .get(slot)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if authority.offset_bytes != 0 || authority_decisions.len() > destination.len() {
            return Err(publication_input_error(
                "fresh authority snapshot exceeds its original fixed allocation",
            ));
        }
        let recorder = self.prepared_segment_recorder()?;
        self.prepared_segment
            .as_mut()
            .expect("checked segment")
            .submit()?;
        self.publication_uploads = vec![(slot, PublicationPayload::Metadata(authority_decisions))];
        let result = (|| {
            let PublicationPayload::Metadata(bytes) = &self.publication_uploads[0].1 else {
                unreachable!("owned authority metadata")
            };
            let mut destination = storage.allocations[slot].view().slice(..bytes.len());
            self.provider
                .htod_launch_metadata_sync_copy_into(bytes, &mut destination)
                .map_err(|error| runtime_error("prepared fresh authority upload", error))?;
            let graph = self
                .captured
                .as_ref()
                .expect("checked original captured graph");
            enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
                graph.launch_in(enqueue)
            })
        })();
        if result.is_err() {
            self.poisoned = true;
            return result;
        }
        self.pending = true;
        Ok(())
    }

    /// True only after the full ordered roster, work certificates, publication
    /// lineage and terminal reader release have been reconciled successfully.
    /// Stream completion alone does not establish a recoverable result.
    pub fn prepared_segment_completion_known(&self) -> bool {
        self.prepared_segment
            .as_ref()
            .is_some_and(|build| build.completed)
    }

    pub fn complete_prepared_segment(
        &mut self,
    ) -> Result<Vec<SemanticPreparedStepOutcome>, SemanticTransitionError> {
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        if !self.pending
            || !self
                .prepared_segment
                .as_ref()
                .is_some_and(|build| build.submitted && !build.completed)
        {
            return Err(SemanticTransitionError::NoPendingLaunch);
        }
        let result = self.complete_prepared_segment_inner();
        if result.is_err() {
            self.poisoned = true;
        } else {
            self.pending = false;
            self.publication_uploads.clear();
            self.continuation_base = None;
            self.admitted_transition = None;
            self.text_binding = None;
        }
        result
    }

    fn complete_prepared_segment_inner(
        &mut self,
    ) -> Result<Vec<SemanticPreparedStepOutcome>, SemanticTransitionError> {
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("prepared completion stream admission", error))?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "prepared graph terminal wait",
            CudaStream::synchronize,
        )?;
        let handles = self
            .prepared_segment
            .as_ref()
            .expect("submitted segment")
            .handles()?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let mut outcomes = Vec::new();
        outcomes
            .try_reserve_exact(handles.len())
            .map_err(|error| runtime_error("prepared outcome reservation", error))?;
        let mut previous = None;
        for step in handles {
            let prepared = self.steps[&step.token]
                .prepared
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let reader = prepared.reader.view();
            let result_view = prepared.result.view();
            let lease = self.publication_read(reader)?[0];
            let result = self.publication_read(result_view)?[0];
            if result.abi == 0 {
                if lease.active != 0
                    || lease.abi != 0
                    || lease.transition_kind != 0
                    || !matches!(lease.status, 1..=5 | 7)
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                #[cfg(feature = "semantic-policy")]
                let token = step.token;
                let outcome = SemanticPreparedStepOutcome::Skipped {
                    step,
                    status: lease.status,
                };
                #[cfg(feature = "semantic-policy")]
                {
                    self.steps
                        .get_mut(&token)
                        .expect("retained original step")
                        .prepared
                        .as_mut()
                        .expect("retained original prepared owner")
                        .observed_outcome = Some(outcome.clone());
                }
                outcomes.push(outcome);
                continue;
            }
            let inputs = Arc::clone(
                self.steps[&step.token]
                    .inputs
                    .as_ref()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?,
            );
            let parent = self.publication_read(inputs.header.view())?[0];
            if previous.is_some_and(|header| header != parent) {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let transition =
                validate_prepared_completion(&lease, &parent, &result, storage.instance)?;
            let bank = u8::try_from(lease.bank)
                .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
            let (state_view, receipts, update_refusal_view) = {
                let prepared = self.steps[&step.token]
                    .prepared
                    .as_ref()
                    .expect("original prepared owner");
                let branch = prepared
                    .branches
                    .get(usize::from(bank))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                (
                    branch.state.view(),
                    branch
                        .receipts
                        .as_ref()
                        .ok_or(SemanticTransitionError::ObservationMismatch)?
                        .view(),
                    branch
                        .model_update
                        .as_ref()
                        .map(|update| (update.refusal.view(), update.canary_results.view())),
                )
            };
            let canary_refusal = match (transition, update_refusal_view) {
                (SemanticTransitionKind::Update, Some((view, results))) => {
                    let results = self.publication_read(results)?;
                    decode_canary_refusal(self.publication_read(view)?[0], &results)?
                }
                (SemanticTransitionKind::Update, None) | (_, Some(_)) => {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                (_, None) => None,
            };
            let state = self.publication_read(state_view)?[0];
            if transition != SemanticTransitionKind::Drain {
                let work = self.steps[&step.token]
                    .prepared
                    .as_ref()
                    .expect("original prepared owner")
                    .model_work
                    .as_ref()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                if !state
                    .execution_work
                    .validate_model(&work.recording, state.status == 11)
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
            }
            let components = if transition == SemanticTransitionKind::Proposal {
                self.publication_read(receipts)?
            } else {
                Vec::new()
            };
            let invocation = parent.rng_binding()?;
            let outcome = self.reconcile_prepared_transition(
                &parent,
                &result,
                state,
                components,
                invocation,
                PreparedTransitionEvidence {
                    transition,
                    canary_refusal,
                },
            )?;
            previous = Some(result.header);
            #[cfg(feature = "semantic-policy")]
            if transition == SemanticTransitionKind::Proposal {
                self.take_prepared_policy_tape(
                    &step,
                    usize::from(bank),
                    invocation,
                    match &outcome {
                        SemanticTransitionOutcome::Refused(refusal) => Some(*refusal),
                        _ => None,
                    },
                )?;
            }
            self.steps
                .get_mut(&step.token)
                .expect("retained original step")
                .prepared
                .as_mut()
                .expect("retained original prepared owner")
                .observed = true;
            #[cfg(feature = "semantic-policy")]
            if transition == SemanticTransitionKind::Update
                && matches!(&outcome, SemanticTransitionOutcome::Published(_))
            {
                self.steps
                    .get_mut(&step.token)
                    .expect("retained original step")
                    .prepared
                    .as_mut()
                    .expect("retained original prepared owner")
                    .group_update_published = true;
            }
            #[cfg(feature = "semantic-policy")]
            let token = step.token;
            let outcome = SemanticPreparedStepOutcome::Completed {
                step,
                invocation,
                bank,
                transition,
                outcome,
            };
            #[cfg(feature = "semantic-policy")]
            {
                let prepared = self
                    .steps
                    .get_mut(&token)
                    .expect("retained original step")
                    .prepared
                    .as_mut()
                    .expect("retained original prepared owner");
                prepared.observed_parent = Some(parent);
                prepared.observed_result = Some(result);
                prepared.observed_outcome = Some(outcome.clone());
            }
            outcomes.push(outcome);
        }
        let control = self.publication_read(storage.control.view())?[0];
        if control.abi != 1
            || control.instance != storage.instance
            || control.reader_gate != 0
            || previous.is_some_and(|header| control.word != header.publication_word)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        self.prepared_segment
            .as_mut()
            .expect("submitted segment")
            .completed = true;
        Ok(outcomes)
    }

    fn reconcile_prepared_transition(
        &mut self,
        parent: &PublicationHeader,
        result: &PreparedStepResult,
        state: DeviceState,
        components: Vec<SemanticTransitionReceipt>,
        invocation: SemanticRngBinding,
        evidence: PreparedTransitionEvidence,
    ) -> Result<SemanticTransitionOutcome, SemanticTransitionError> {
        let PreparedTransitionEvidence {
            transition,
            canary_refusal,
        } = evidence;
        if result.refusal != 0 || state.status == 10 {
            return Err(SemanticTransitionError::PublicationRefused {
                status: result.refusal,
            });
        }
        if matches!(state.status, 2 | 5 | 11 | 12..=15) {
            let canary_refusal = if state.status == 15 {
                Some(canary_refusal.ok_or(SemanticTransitionError::ObservationMismatch)?)
            } else {
                None
            };
            let refusal = refused_terminal(
                &state,
                invocation,
                SemanticActionCatalogue::current().binding(),
                self.binding().digest,
                canary_refusal,
            )?;
            if result.word != parent.publication_word || result.header != *parent {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let (root, snapshot) = self.observe_publication_root(&state, parent, 0)?;
            refused_root_cleanup(
                &state,
                self.graph.transition_arena()[1],
                u64::from(root.slot()),
                root.generation(),
            )?;
            self.root = root;
            self.base_snapshot = snapshot;
            self.next_proposal = parent.proposal;
            return Ok(SemanticTransitionOutcome::Refused(refusal));
        }
        match state.status {
            7 => return Err(SemanticTransitionError::InvalidTaskBank),
            8 => return Err(SemanticTransitionError::InvalidTaskBase),
            9 => return Err(SemanticTransitionError::TaskOwnerFailure),
            _ => {}
        }
        let next = parent
            .proposal
            .checked_add(u64::from(transition == SemanticTransitionKind::Proposal))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        if state.status != 0
            || result.word == parent.publication_word
            || result.header.proposal != next
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let winner = if transition == SemanticTransitionKind::Proposal {
            state.task_evaluation.winner
        } else {
            0
        };
        let index = match winner {
            0 => 0,
            1 => 3,
            2 => 6,
            _ => return Err(SemanticTransitionError::ObservationMismatch),
        };
        if winner > 0 && state.retired_roots_mask & (1 << (winner - 1)) != 0 {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let root = self.observe_publication_root(&state, &result.header, index)?;
        self.finish_observed_transition(
            state,
            components,
            invocation,
            Some((result.header, root, transition)),
            true,
        )
    }
}

#[cfg(test)]
mod prepared_completion_tests {
    use super::*;

    #[test]
    fn prepared_allocation_plan_counts_original_banks_before_expanding_bound() {
        let schema = SemanticFeedbackSchema::new([&[1u8; 64], &[2u8; 64], &[3u8; 64]]).unwrap();
        let feedback = FeedbackAllocationPlan::new(&schema, 2, 3).unwrap();
        let expected_feedback = 2 * schema.feature_width * size_of::<f32>()
            + 2 * 9
            + (2 * 42 + 2 + 3 + 3 * SEMANTIC_FEEDBACK_SUPPORT_FIELDS.len()) * size_of::<u64>()
            + 6 * 4 * size_of::<u64>();
        assert_eq!(feedback.bytes, expected_feedback);
        let input_bytes = PreparedStepInputs::allocation_bytes(&[]).unwrap();
        assert_eq!(
            input_bytes,
            size_of::<PublicationHeader>() + 32 * size_of::<SourceSlot>() + u64::BITS as usize
        );
        let plans = [
            StepInputPlan {
                role: 1,
                index: 0,
                layout: SemanticTensorLayout::default(),
                banks: [
                    StepInputBankPlan {
                        storage_slot: 0,
                        span: 0..1024,
                    },
                    StepInputBankPlan {
                        storage_slot: 0,
                        span: 0..1024,
                    },
                ],
            },
            StepInputPlan {
                role: 2,
                index: 0,
                layout: SemanticTensorLayout::default(),
                banks: [
                    StepInputBankPlan {
                        storage_slot: 1,
                        span: 0..32,
                    },
                    StepInputBankPlan {
                        storage_slot: 2,
                        span: 0..32,
                    },
                ],
            },
        ];
        assert_eq!(
            PreparedStepInputs::allocation_bytes(&plans).unwrap(),
            input_bytes
                + 2 * (size_of::<PublicationRange>() + 2 * size_of::<PublicationStepInput>())
                + 32
        );
        assert!(PreparedStepInputs::allocation_bytes(&[StepInputPlan {
            banks: [
                StepInputBankPlan {
                    storage_slot: 1,
                    span: 0..usize::MAX,
                },
                StepInputBankPlan {
                    storage_slot: 2,
                    span: 0..usize::MAX,
                },
            ],
            ..plans[1].clone()
        }])
        .is_err());
        let step_bytes = prepared_step_allocation_bytes(input_bytes, feedback.bytes, 0).unwrap();
        assert_eq!(
            step_bytes,
            (input_bytes
                + feedback.bytes
                + size_of::<PublicationLease>()
                + size_of::<PreparedStepResult>()) as u64
        );
        assert_eq!(
            prepared_segment_allocation_bytes(step_bytes, 3, 0).unwrap(),
            3 * step_bytes
        );
        assert!(prepared_segment_allocation_bytes(step_bytes, 0, 0).is_err());
        assert!(prepared_segment_allocation_bytes(step_bytes, usize::MAX, 0).is_err());
    }

    #[test]
    fn prepared_scope_blocks_ordinary_rebinding_until_retirement() {
        let issuer = Arc::new(());
        let mut build = PreparedSegmentState::new(
            Arc::clone(&issuer),
            vec![1],
            std::iter::once(SemanticTransitionKind::Proposal),
            SemanticSegmentColdCapacity {
                tensor_content_capacity: 1,
                model_work_capacity: 1,
                segment_capacity_bytes: 1,
                other_external_cuda_bytes: 0,
            },
        )
        .unwrap();
        assert!(validate_rebinding_ownership(None, false).is_ok());
        assert!(validate_rebinding_ownership(None, true).is_err());
        assert!(validate_rebinding_ownership(Some(&build), false).is_err());
        let step = build.handles().unwrap().remove(0);
        build.enter(&step, &issuer).unwrap();
        build.leave(&step, &issuer).unwrap();
        build.finish().unwrap();
        build.submit().unwrap();
        build.completed = true;
        assert!(validate_rebinding_ownership(Some(&build), false).is_err());
    }

    #[test]
    fn prepared_submission_is_once_only_after_complete_construction() {
        let issuer = Arc::new(());
        let mut build = PreparedSegmentState::new(
            Arc::clone(&issuer),
            vec![1],
            std::iter::once(SemanticTransitionKind::Proposal),
            SemanticSegmentColdCapacity {
                tensor_content_capacity: 1,
                model_work_capacity: 1,
                segment_capacity_bytes: 1,
                other_external_cuda_bytes: 0,
            },
        )
        .unwrap();
        assert!(build.submit().is_err());
        let step = build.handles().unwrap().remove(0);
        build.enter(&step, &issuer).unwrap();
        build.leave(&step, &issuer).unwrap();
        build.finish().unwrap();
        build.submit().unwrap();
        assert!(build.submit().is_err());
        build.completed = true;
        assert!(build.submit().is_err());
    }

    #[test]
    fn completion_uses_original_parent_and_requires_device_release() {
        let parent = PublicationHeader {
            abi: 1,
            publication_word: 2,
            // Proposal publication and model-weight banks advance separately.
            neural_bank: 1,
            sealed_epoch: 1,
            proposal: 37,
            model_generation: 9,
            family_id: 3,
            stream_serial: 91,
            ..PublicationHeader::default()
        };
        let mut lease = PublicationLease {
            abi: 1,
            word: 2,
            epoch: 1,
            transition_kind: 1,
            ..PublicationLease::default()
        };
        let mut result = PreparedStepResult {
            abi: 1,
            word: 5,
            advanced: 1,
            header: PublicationHeader {
                abi: 1,
                base_word: 2,
                publication_word: 5,
                sealed_epoch: 2,
                proposal: 38,
                ..parent
            },
            attempt: AttemptReceipt {
                abi: 2,
                transition_kind: 1,
                instance: parent.instance,
                base_word: 2,
                next_word: 5,
                logical_digest: parent.logical_digest,
                ..AttemptReceipt::default()
            },
            ..PreparedStepResult::default()
        };
        assert_eq!(
            validate_prepared_completion(&lease, &parent, &result, parent.instance).unwrap(),
            SemanticTransitionKind::Proposal
        );
        assert_eq!(parent.rng_binding().unwrap().proposal, 37);
        lease.active = 1;
        assert!(validate_prepared_completion(&lease, &parent, &result, parent.instance).is_err());
        lease.active = 0;
        result.word = 8;
        assert!(validate_prepared_completion(&lease, &parent, &result, parent.instance).is_err());
        result.word = 5;
        lease.transition_kind = 0;
        assert!(validate_prepared_completion(&lease, &parent, &result, parent.instance).is_err());
    }
}

struct UnreleasedPublicationOwners {
    _graph: SemanticHypergraph,
    _publication: Arc<PublicationStorage>,
    _training_views: Option<Arc<SemanticTrainingViewArena>>,
    _training_origins: Option<Arc<TrackedCudaSlice<SemanticTrainingViewOriginRecord>>>,
    _readers: BTreeMap<u64, PublishedReader>,
    _steps: BTreeMap<u64, StepContentStorage>,
    _initial_prefill_content: Option<RetainedInitialPrefillContent>,
    _prepared_resources: Vec<Arc<dyn Send + Sync>>,
    _prepared_segment: Option<PreparedSegmentState>,
    _text_binding: Option<Arc<TextBindingStorage>>,
    #[cfg(feature = "semantic-policy")]
    _policy: Option<PolicyStorage>,
    #[cfg(feature = "semantic-policy")]
    _pending_policy: Option<PendingPolicyStorage>,
    #[cfg(feature = "semantic-policy")]
    _policy_tapes: Vec<PolicyTape>,
    _events: Vec<cudarc::driver::CudaEvent>,
    _uploads: Vec<(usize, PublicationPayload)>,
    _stream: Arc<CudaStream>,
}

thread_local! {
    // Driver/function/semantic owners are constructing-thread confined. A
    // violated explicit-release contract must retain these actual owners even
    // when that thread exits; no unsafe Send or foreign-thread destructor runs.
    static UNRELEASED_PUBLICATIONS: std::cell::RefCell<Vec<std::mem::ManuallyDrop<UnreleasedPublicationOwners>>> = const { std::cell::RefCell::new(Vec::new()) };
}

impl Drop for SemanticTransitionSession {
    fn drop(&mut self) {
        // Captured work retires before either the semantic owner or its banks.
        drop(self.captured.take());
        if !self.readers.is_empty()
            || !self.steps.is_empty()
            || self
                .prepared_segment
                .as_ref()
                .is_some_and(|build| (build.capturing || build.submitted) && !build.completed)
        {
            if let Some(publication) = self.publication.take() {
                // SAFETY: graph is taken exactly once here and its normal
                // destructor is disabled by ManuallyDrop in Session storage.
                let graph = unsafe { std::mem::ManuallyDrop::take(&mut self.graph) };
                let owners = UnreleasedPublicationOwners {
                    _graph: graph,
                    _publication: publication,
                    _training_views: self.training_views.take(),
                    _training_origins: self.training_origins.take(),
                    _readers: std::mem::take(&mut self.readers),
                    _events: std::mem::take(&mut self.release_events),
                    _steps: std::mem::take(&mut self.steps),
                    _initial_prefill_content: self.retained_initial_prefill.take(),
                    _text_binding: self.text_binding.take(),
                    _prepared_resources: std::mem::take(&mut self.prepared_resources),
                    _prepared_segment: self.prepared_segment.take(),
                    #[cfg(feature = "semantic-policy")]
                    _policy: self.policy.take(),
                    #[cfg(feature = "semantic-policy")]
                    _pending_policy: self.pending_policy.take(),
                    #[cfg(feature = "semantic-policy")]
                    _policy_tapes: std::mem::take(&mut self.policy_tapes),
                    _uploads: std::mem::take(&mut self.publication_uploads),
                    _stream: Arc::clone(&self.stream),
                };
                eprintln!("semantic publication owners retained: Session dropped with unreleased readers or retained steps");
                let owners = std::mem::ManuallyDrop::new(owners);
                let _ = UNRELEASED_PUBLICATIONS
                    .try_with(|quarantine| quarantine.borrow_mut().push(owners));
                return;
            }
        }
        // SAFETY: no active reader can reach the graph, and the captured exec
        // retired above. This is the graph's unique normal destructor call.
        unsafe { std::mem::ManuallyDrop::drop(&mut self.graph) };
    }
}

impl SemanticTransitionSession {
    /// Retain the actual allocation owner and serial stream for a private successor.
    /// Source and successor allocations remain charged to this same provider's
    /// resource stack; constructing a successor does not grant a fresh budget
    /// or consume another permanent stream-pool slot.
    pub fn checkpoint_allocation_domain(
        &self,
    ) -> Result<(Arc<CudaKernelProvider>, ResidentExecutionDomain), SemanticTransitionError> {
        self.ensure_quiescent()?;
        Ok((Arc::clone(&self.provider), self.domain.clone()))
    }

    /// Decode and validate one complete native material before allocating a new
    /// CUDA owner, returning only the original immutable admission needed to
    /// construct that fresh owner. This is the same state codec consumed by
    /// `restore_state_material`, not an independently serialized graph.
    pub fn state_material_admission(
        bytes: &[u8],
    ) -> Result<SemanticAdmissionRecords, SemanticTransitionError> {
        PublicationMaterial::decode(bytes)?
            .graph
            .admission_records()
            .map_err(SemanticTransitionError::Semantic)
    }

    /// Fixed compact checkpoint v2 extent, also reserved by the cold exporter.
    pub const CHECKPOINT_REFERENT_BYTES: usize = b"XLOG-CHECKPOINT-REFERENT\0".len()
        + 4
        + 32
        + 8
        + 104
        + 32
        + 8
        + 32
        + 32
        + 8
        + 3 * 32
        + 5 * 32
        + 1;

    /// Decode the original sealed material once and project its selected publication.
    /// This performs no CUDA allocation and does not create a runnable owner.
    pub fn state_material_projection(
        bytes: &[u8],
    ) -> Result<SemanticCheckpointNativeProjection, SemanticTransitionError> {
        let material = PublicationMaterial::decode(bytes)?;
        let header = material.bank.header;
        Ok(SemanticCheckpointNativeProjection {
            publication: SemanticPublishedIdentity {
                instance: header.instance,
                word: header.publication_word,
                logical_digest: header.logical_digest,
                state_digest: header.state_digest,
            },
            semantic_root: header.semantic_digest,
            model_generation: header.model_generation,
        })
    }

    /// Inspect original source and cache operands through the sole full-state
    /// decoder, without a CUDA owner or a new historical execution claim.
    pub fn state_material_input_projection(
        bytes: &[u8],
    ) -> Result<SemanticPublicationInputProjection, SemanticTransitionError> {
        let material = PublicationMaterial::decode(bytes)?;
        let header = material.bank.header;
        let range = |role| {
            material
                .ranges
                .iter()
                .find(|item| (item.range.role, item.range.index) == (role, 0))
                .ok_or(SemanticTransitionError::ObservationMismatch)
        };
        let prefix_material = range(1)?;
        let provenance_material = range(2)?;
        if prefix_material.range.logical_begin != 0
            || prefix_material.range.logical_end != header.prefix_extent
            || header
                .prefix_extent
                .checked_mul(size_of::<SemanticTextSlot>() as u64)
                != Some(prefix_material.bytes.len() as u64)
            || !provenance_material
                .bytes
                .len()
                .is_multiple_of(size_of::<TokenProvenance>())
            || header.prefix_extent > material.contract.prefix_capacity
            || header.ring_head >= 32
        {
            return Err(publication_input_error(
                "publication text material has inconsistent extents",
            ));
        }
        // SAFETY: fixed, padding-free, all-bit-valid integral ABI records. The
        // codec has checked each sealed record's bytes and the exact row sizes.
        let prefix = prefix_material
            .bytes
            .as_chunks::<{ size_of::<SemanticTextSlot>() }>()
            .0
            .iter()
            .map(|bytes| unsafe { bytes.as_ptr().cast::<SemanticTextSlot>().read_unaligned() })
            .collect::<Vec<_>>();
        let records = provenance_material
            .bytes
            .as_chunks::<{ size_of::<TokenProvenance>() }>()
            .0
            .iter()
            .map(|bytes| unsafe { bytes.as_ptr().cast::<TokenProvenance>().read_unaligned() })
            .collect::<Vec<_>>();
        for (position, slot) in prefix.iter().enumerate() {
            if slot.logical_position != position as u64
                || slot.kind != 1
                || slot.valid != 1
                || slot.committed != 1
                || slot.recomputed != 1
            {
                return Err(publication_input_error(
                    "publication prefix is not the exact committed ordered prefix",
                ));
            }
        }
        for slot in prefix.iter().chain(&material.bank.source) {
            if slot.kind != 1 {
                if slot.provenance != 0 || slot.provenance_record != 0 {
                    return Err(publication_input_error(
                        "unfilled source carries token provenance",
                    ));
                }
                continue;
            }
            let record = usize::try_from(slot.provenance_record)
                .ok()
                .and_then(|index| records.get(index))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if !matches!(slot.provenance, 1 | 2)
                || record.logical_position != slot.logical_position
                || record.token != slot.token
                || record.origin_logical_digest == Identity256::default()
                || record.authority_closure_digest == Identity256::default()
                || record.record_digest == Identity256::default()
                || (slot.provenance == 1)
                    != (record.action_receipt_digest == Identity256::default())
            {
                return Err(publication_input_error(
                    "publication token differs from its original source or generated origin",
                ));
            }
        }
        let prefix_identity = Identity256::from_bytes(
            range(3)?
                .bytes
                .as_slice()
                .try_into()
                .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
        );
        let cache = material
            .ranges
            .iter()
            .filter(|item| matches!(item.range.role, 4..=13))
            .map(|item| {
                item.cache_projection(
                    *material
                        .layouts
                        .get(&(item.range.role, item.range.index))
                        .ok_or(SemanticTransitionError::ObservationMismatch)?,
                )
            })
            .collect::<Result<Vec<_>, _>>()?;
        let token_provenance = records
            .into_iter()
            .map(|record| SemanticTokenProvenance {
                source_slot: record.source_slot,
                logical_position: record.logical_position,
                token: record.token,
                base_word: record.base_word,
                proposal: record.proposal,
                ordinal: record.ordinal,
                action_receipt_digest: record.action_receipt_digest,
                authority_generation: record.authority_generation,
                origin_logical_digest: record.origin_logical_digest,
                authority_closure_digest: record.authority_closure_digest,
                record_digest: record.record_digest,
            })
            .collect();
        Ok(SemanticPublicationInputProjection {
            publication: SemanticPublishedIdentity {
                instance: header.instance,
                word: header.publication_word,
                logical_digest: header.logical_digest,
                state_digest: header.state_digest,
            },
            semantic_root: header.semantic_digest,
            model_generation: header.model_generation,
            model_geometry_digest: header.model_geometry_digest,
            model_numerical_digest: header.model_numerical_digest,
            neural_generation: header.neural_generation,
            cache_generation: header.cache_generation,
            prefix_extent: header.prefix_extent,
            ring_head: header.ring_head,
            prefix_identity,
            prefix,
            source: material.bank.source,
            token_provenance,
            cache,
        })
    }

    /// Allocate every native step owner before the first capture begins.
    /// Freeze requested modes and reserve the complete segment before creating
    /// per-step storage. Device admission alone selects terminal drain.
    pub fn prepare_segment_steps(
        &mut self,
        transitions: impl ExactSizeIterator<Item = SemanticTransitionKind> + Clone,
        cold_capacity: SemanticSegmentColdCapacity,
    ) -> Result<Vec<SemanticPreparedStep>, SemanticTransitionError> {
        self.ensure_rebindable()?;
        let external_floor = cold_capacity.external_floor()?;
        let transitions = transitions.collect::<Vec<_>>();
        if transitions.is_empty() || transitions.contains(&SemanticTransitionKind::Drain) {
            return Err(publication_input_error(
                "a prepared segment requires frozen proposal, recompute, or update steps",
            ));
        }
        let update_count = transitions
            .iter()
            .filter(|kind| **kind == SemanticTransitionKind::Update)
            .count();
        let training_view = if update_count == 0 {
            None
        } else {
            Some(Arc::clone(self.training_views.as_ref().ok_or_else(
                || {
                    publication_input_error(
                        "prepared updates require the native training-view arena",
                    )
                },
            )?))
        };
        if self.prepared_segment.is_some()
            || !self.readers.is_empty()
            || self.captured.is_some()
            || self.admitted_transition.is_some()
            || self.text_binding.is_some()
        {
            return Err(publication_input_error("segment construction requires an idle Session with no acquired reader or prior executable"));
        }
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let transition_bound = transitions.len();
        let replay_bytes = PreparedReplayCustody::allocation_bytes(
            &storage,
            self.graph.transition_arena_view().len(),
        )?
        .checked_mul(transition_bound as u64)
        .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let bound = u64::try_from(transition_bound)
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        let end = self
            .next_reader
            .checked_add(bound)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let schema = SemanticFeedbackSchema::new(self.feedback_statement_bytes()?)?;
        let descriptor = self.descriptor();
        let input_plans = PreparedStepInputs::plan(&storage)?;
        let feedback_plan = FeedbackAllocationPlan::new(
            &schema,
            storage.contract_value.feedback_capacity,
            descriptor.arena[4],
        )?;
        let block_bytes = storage
            .physical_parameter_roster
            .as_ref()
            .map_or(Some(0usize), |roster| {
                roster.len().checked_mul(6 * size_of::<f64>())
            })
            .and_then(|bytes| bytes.checked_mul(2))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        #[cfg(not(feature = "semantic-policy"))]
        let policy_bytes = block_bytes;
        #[cfg(feature = "semantic-policy")]
        let policy_bytes = policy_buffer_bytes(&self.policy_layout()?, self.codebooks.input_cells)?
            .checked_add(self.codebooks.input_cells)
            .and_then(|n| n.checked_add(COMPONENT_COUNT * size_of::<SemanticTransitionReceipt>()))
            .and_then(|n| n.checked_add(size_of::<DeviceState>()))
            .and_then(|n| n.checked_mul(2))
            .and_then(|n| n.checked_add(block_bytes))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let step_bytes = prepared_step_allocation_bytes(
            PreparedStepInputs::allocation_bytes(&input_plans)?,
            feedback_plan.bytes,
            policy_bytes,
        )?;
        let training_origin_bytes = if self.training_views.is_some() {
            transition_bound
                .checked_mul(size_of::<SemanticTrainingViewOriginRecord>())
                .ok_or(SemanticTransitionError::GenerationExhausted)?
        } else {
            0
        };
        let training_view_bytes = training_view.as_ref().map_or(Ok(0usize), |arena| {
            arena
                .selection_bytes()?
                .checked_mul(update_count)
                .ok_or(SemanticTransitionError::GenerationExhausted)
        })?;
        let model_forward_seal_count = storage.bank_templates[0]
            .iter()
            .filter(|range| matches!(range.role, 18..=25))
            .count();
        let model_update_bank_metadata_bytes = model_forward_seal_count
            .checked_mul(size_of::<ModelForwardSealInput>())
            .and_then(|bytes| {
                bytes.checked_add(
                    1 + 5 * size_of::<SemanticTrainingCanaryResultRecord>()
                        + size_of::<SemanticTrainingCanaryRefusalRecord>()
                        + 2 * size_of::<ModelForwardReceipt>(),
                )
            })
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let update_binding_bytes = update_count
            .checked_mul(2)
            .and_then(|count| count.checked_mul(storage.model_slots.len()))
            .and_then(|count| count.checked_mul(size_of::<ModelUpdateBinding>()))
            .and_then(|bytes| {
                update_count
                    .checked_mul(2)
                    .and_then(|count| count.checked_mul(model_update_bank_metadata_bytes))
                    .and_then(|metadata| bytes.checked_add(metadata))
            })
            .and_then(|bytes| {
                update_count
                    .checked_mul(transition_bound)
                    .and_then(|count| count.checked_mul(size_of::<ModelUpdateEvidenceSource>()))
                    .and_then(|evidence| bytes.checked_add(evidence))
            })
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let update_binding_bytes = u64::try_from(update_binding_bytes)
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        let base_bytes =
            prepared_segment_allocation_bytes(step_bytes, transition_bound, training_origin_bytes)?
                .checked_add(
                    u64::try_from(training_view_bytes)
                        .map_err(|_| SemanticTransitionError::GenerationExhausted)?,
                )
                .and_then(|bytes| bytes.checked_add(update_binding_bytes))
                .and_then(|bytes| bytes.checked_add(replay_bytes))
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
        // Each model-bearing prepared branch binds the complete roster once. Its
        // ranges, contract snapshot, and roster are native cold allocations,
        // even though the live producer addresses arrive after this claim.
        let publication_allocation_bytes = storage
            .allocations
            .iter()
            .map(TrackedCudaSlice::len)
            .collect::<Vec<_>>();
        let model_content_bytes = storage
            .bank_templates
            .iter()
            .try_fold(0u64, |total, directory| {
                if !directory.iter().any(|range| range.role == 18) {
                    return Ok(total);
                }
                let ranges = directory
                    .iter()
                    .enumerate()
                    .filter_map(|(index, range)| matches!(range.role, 18..=20).then_some(index))
                    .collect::<Vec<_>>();
                let plan =
                    model_content_copy_plan(directory, &ranges, &publication_allocation_bytes)?;
                let bytes = plan
                    .directory_offsets
                    .len()
                    .checked_mul(size_of::<PublicationRange>())
                    .and_then(|bytes| bytes.checked_add(plan.contract_span.len()))
                    .and_then(|bytes| {
                        ranges
                            .len()
                            .checked_mul(2 * size_of::<u64>())
                            .and_then(|roster| bytes.checked_add(roster))
                    })
                    .and_then(|bytes| u64::try_from(bytes).ok())
                    .ok_or(SemanticTransitionError::GenerationExhausted)?;
                total
                    .checked_add(bytes)
                    .ok_or(SemanticTransitionError::GenerationExhausted)
            })?
            .checked_mul(bound)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let late_native_bytes = cold_capacity.late_native_bytes(transition_bound)?;
        let bytes = base_bytes
            .checked_add(model_content_bytes)
            .and_then(|bytes| bytes.checked_add(late_native_bytes))
            .and_then(|bytes| bytes.checked_add(external_floor))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("segment preparation stream admission", error))?;
        let mut free_bytes = 0usize;
        let mut total_bytes = 0usize;
        // SAFETY: the stream admission binds this Session's CUDA context and
        // excludes managed capture while the driver writes both host scalars.
        unsafe { sys::cuMemGetInfo_v2(&mut free_bytes, &mut total_bytes) }
            .result()
            .map_err(|error| runtime_error("prepared segment physical memory snapshot", error))?;
        if u128::from(bytes) > free_bytes as u128 {
            return Err(runtime_error(
                "prepared segment physical memory admission",
                format!("declared cold claim {bytes} bytes exceeds {free_bytes} free CUDA bytes"),
            ));
        }
        // Claim the declared local and runtime budgets before any T-sized host
        // collection or native allocation. Every fixed bank consumes this claim.
        let mut reservation = self
            .provider
            .memory()
            .reserve_bytes(bytes)
            .map_err(|error| runtime_error("prepared segment reservation", error))?;
        let training_origins = if training_origin_bytes == 0 {
            None
        } else {
            let origins = reservation
                .alloc::<SemanticTrainingViewOriginRecord>(transition_bound)
                .map_err(|error| runtime_error("training origin roster allocation", error))?;
            upload_publication(
                &self.provider,
                &vec![SemanticTrainingViewOriginRecord::default(); transition_bound],
                &origins,
            )?;
            Some(Arc::new(origins))
        };
        let mut tokens = Vec::new();
        tokens
            .try_reserve_exact(transition_bound)
            .map_err(|error| runtime_error("prepared token reservation", error))?;
        tokens.extend((self.next_reader..end).map(|token| token + 1));
        let build = PreparedSegmentState::new(
            Arc::clone(&self.publication_issuer),
            tokens,
            transitions.iter().copied(),
            cold_capacity,
        )?;
        let handles = build.handles()?;
        let kernel = |name| {
            self.provider
                .device()
                .inner()
                .get_func("xlog_semantic_transition", name)
                .ok_or_else(|| runtime_error("kernel lookup", format!("{name} unavailable")))
        };
        let admit = kernel("semantic_publication_step_admit")?;
        let kind_gate = kernel("semantic_publication_step_kind_gate")?;
        let kind_bank_gate = kernel("semantic_publication_step_kind_bank_gate")?;
        let active_gate = kernel("semantic_publication_step_active_gate")?;
        let drain_prepare = kernel("semantic_publication_prepare_drain")?;
        let release = kernel("semantic_publication_step_release")?;
        let witness = kernel("semantic_tensor_content_witness")?;
        let content_guard = kernel("semantic_publication_content_guard")?;
        let result_kernel = kernel("semantic_publication_step_result")?;
        let model_update_admissibility_copy =
            kernel("semantic_publication_prepare_model_update_admissibility")?;
        let model_update_forward_receipt =
            kernel("semantic_publication_record_model_forward_receipts")?;
        let model_update_copy = kernel("semantic_publication_apply_model_update")?;
        self.prepared_segment = Some(build);
        self.next_reader = end;
        let result = (|| {
            for (ordinal, (handle, kind)) in handles.iter().zip(&transitions).enumerate() {
                let reader = reservation
                    .alloc(1)
                    .map_err(|error| runtime_error("prepared reader allocation", error))?;
                let result = reservation
                    .alloc(1)
                    .map_err(|error| runtime_error("prepared result allocation", error))?;
                let (update_evidence, update_evidence_owners) = if *kind
                    == SemanticTransitionKind::Update
                {
                    #[cfg(feature = "semantic-policy")]
                    let mut values = vec![ModelUpdateEvidenceSource::default(); transition_bound];
                    #[cfg(not(feature = "semantic-policy"))]
                    let values = vec![ModelUpdateEvidenceSource::default(); transition_bound];
                    #[cfg(feature = "semantic-policy")]
                    let mut owners = Vec::new();
                    #[cfg(not(feature = "semantic-policy"))]
                    let owners = Vec::new();
                    #[cfg(feature = "semantic-policy")]
                    for source_ordinal in 0..ordinal {
                        if transitions[source_ordinal] != SemanticTransitionKind::Proposal {
                            continue;
                        }
                        let source = &self.steps[&handles[source_ordinal].token];
                        let prepared = source
                            .prepared
                            .as_ref()
                            .ok_or(SemanticTransitionError::ObservationMismatch)?;
                        let inputs = source
                            .inputs
                            .as_ref()
                            .ok_or(SemanticTransitionError::ObservationMismatch)?;
                        let origin = prepared
                            .training_origin
                            .clone()
                            .ok_or(SemanticTransitionError::ObservationMismatch)?;
                        let owner = ModelUpdateEvidenceOwner {
                            lease: prepared.reader.view(),
                            parent_header: inputs.header.view(),
                            result: prepared.result.view(),
                            origin,
                            states: [
                                prepared.branches[0].state.view(),
                                prepared.branches[1].state.view(),
                            ],
                        };
                        values[source_ordinal] = ModelUpdateEvidenceSource {
                            lease: *owner.lease.device_ptr(),
                            parent_header: *owner.parent_header.device_ptr(),
                            result: *owner.result.device_ptr(),
                            origin: *owner.origin.device_ptr(),
                            states: [*owner.states[0].device_ptr(), *owner.states[1].device_ptr()],
                        };
                        owners.push(owner);
                    }
                    let evidence = reservation
                        .alloc::<ModelUpdateEvidenceSource>(transition_bound)
                        .map_err(|error| {
                            runtime_error("model update evidence allocation", error)
                        })?;
                    upload_publication(&self.provider, &values, &evidence)?;
                    (Some(Arc::new(evidence)), Some(Arc::new(owners)))
                } else {
                    (None, None)
                };
                let mut allocate_model_update = || {
                    if *kind != SemanticTransitionKind::Update {
                        return Ok(None);
                    }
                    let bindings = reservation
                        .alloc::<ModelUpdateBinding>(storage.model_slots.len())
                        .map_err(|error| runtime_error("model update binding allocation", error))?;
                    upload_publication(
                        &self.provider,
                        &vec![ModelUpdateBinding::default(); storage.model_slots.len()],
                        &bindings,
                    )?;
                    let forward_seals = reservation
                        .alloc::<ModelForwardSealInput>(model_forward_seal_count)
                        .map_err(|error| runtime_error("model forward seal allocation", error))?;
                    upload_publication(
                        &self.provider,
                        &vec![ModelForwardSealInput::default(); model_forward_seal_count],
                        &forward_seals,
                    )?;
                    let forward_receipts =
                        reservation
                            .alloc::<ModelForwardReceipt>(2)
                            .map_err(|error| {
                                runtime_error("model forward receipt allocation", error)
                            })?;
                    upload_publication(
                        &self.provider,
                        &[ModelForwardReceipt::default(); 2],
                        &forward_receipts,
                    )?;
                    let admissibility = reservation.alloc::<u8>(1).map_err(|error| {
                        runtime_error("model update admissibility allocation", error)
                    })?;
                    upload_publication(&self.provider, &[0u8], &admissibility)?;
                    let canary_results = reservation
                        .alloc::<SemanticTrainingCanaryResultRecord>(5)
                        .map_err(|error| {
                            runtime_error("model update canary result allocation", error)
                        })?;
                    upload_publication(
                        &self.provider,
                        &[SemanticTrainingCanaryResultRecord::default(); 5],
                        &canary_results,
                    )?;
                    let refusal = reservation
                        .alloc::<SemanticTrainingCanaryRefusalRecord>(1)
                        .map_err(|error| runtime_error("model update refusal allocation", error))?;
                    upload_publication(
                        &self.provider,
                        &[SemanticTrainingCanaryRefusalRecord::default()],
                        &refusal,
                    )?;
                    Ok(Some(PreparedModelUpdate {
                        bindings,
                        evidence: Arc::clone(
                            update_evidence
                                .as_ref()
                                .ok_or(SemanticTransitionError::ObservationMismatch)?,
                        ),
                        evidence_owners: Arc::clone(
                            update_evidence_owners
                                .as_ref()
                                .ok_or(SemanticTransitionError::ObservationMismatch)?,
                        ),
                        forward_seals,
                        forward_receipts,
                        admissibility,
                        canary_results,
                        refusal,
                        output: None,
                        forward_recorded: 0,
                        admissibility_copy: model_update_admissibility_copy.clone(),
                        forward_receipt: model_update_forward_receipt.clone(),
                        copy: model_update_copy.clone(),
                    }))
                };
                let model_updates: [Option<PreparedModelUpdate>; 2] =
                    [allocate_model_update()?, allocate_model_update()?];
                let inputs = Arc::new(PreparedStepInputs::allocate_reserved(
                    &self.provider,
                    Arc::clone(&storage),
                    reader.view(),
                    input_plans.clone(),
                    &mut reservation,
                )?);
                let feedback = FeedbackBuffers::allocate_reserved(
                    &self.provider,
                    schema.clone(),
                    feedback_plan,
                    &mut reservation,
                )?;
                let mut allocate_block_slot = || -> Result<_, SemanticTransitionError> {
                    storage
                        .physical_parameter_roster
                        .as_ref()
                        .map(|roster| {
                            let cells = roster
                                .len()
                                .checked_mul(6)
                                .ok_or(SemanticTransitionError::GenerationExhausted)?;
                            reservation
                                .alloc::<f64>(cells)
                                .map(Arc::new)
                                .map_err(|error| {
                                    runtime_error("prepared block bound allocation", error)
                                })
                        })
                        .transpose()
                };
                let [blocks_zero, blocks_one] = [allocate_block_slot()?, allocate_block_slot()?];
                #[cfg(feature = "semantic-policy")]
                let [branch_zero, branch_one] = [
                    self.prepare_step_policy_storage(&mut reservation)?,
                    self.prepare_step_policy_storage(&mut reservation)?,
                ];
                let [model_update_zero, model_update_one] = model_updates;
                #[cfg(feature = "semantic-policy")]
                let (policy_buffers_zero, support_zero, receipts_zero, state_zero) = branch_zero;
                #[cfg(feature = "semantic-policy")]
                let (policy_buffers_one, support_one, receipts_one, state_one) = branch_one;
                let branches = [
                    PreparedBranchStorage {
                        model_update: model_update_zero,
                        continuation: None,
                        numerical_block_snapshot: blocks_zero,
                        #[cfg(feature = "semantic-policy")]
                        policy_buffers: Some(policy_buffers_zero),
                        #[cfg(feature = "semantic-policy")]
                        policy: None,
                        #[cfg(feature = "semantic-policy")]
                        support: Some(support_zero),
                        #[cfg(feature = "semantic-policy")]
                        receipts: Some(receipts_zero),
                        #[cfg(feature = "semantic-policy")]
                        state: state_zero,
                        #[cfg(feature = "semantic-policy")]
                        policy_sources: Vec::new(),
                        #[cfg(feature = "semantic-policy")]
                        policy_witness: None,
                    },
                    PreparedBranchStorage {
                        model_update: model_update_one,
                        continuation: None,
                        numerical_block_snapshot: blocks_one,
                        #[cfg(feature = "semantic-policy")]
                        policy_buffers: Some(policy_buffers_one),
                        #[cfg(feature = "semantic-policy")]
                        policy: None,
                        #[cfg(feature = "semantic-policy")]
                        support: Some(support_one),
                        #[cfg(feature = "semantic-policy")]
                        receipts: Some(receipts_one),
                        #[cfg(feature = "semantic-policy")]
                        state: state_one,
                        #[cfg(feature = "semantic-policy")]
                        policy_sources: Vec::new(),
                        #[cfg(feature = "semantic-policy")]
                        policy_witness: None,
                    },
                ];
                let mut step = StepContentStorage::new();
                step.inputs = Some(Arc::clone(&inputs));
                step.feedback.push(feedback);
                step.prepared = Some(PreparedStepStorage {
                    reader,
                    // Every executed step's completed binding keeps its own
                    // acquired inputs after later transitions reuse either bank.
                    replay_custody: Some(PreparedReplayCustody::allocate(
                        &self.provider,
                        &storage,
                        &inputs,
                        self.graph.transition_arena_view().len(),
                        &mut reservation,
                        &self.learning_phases,
                    )?),
                    branches,
                    digests: None,
                    next_digest: 0,
                    model_work: None,
                    admit: admit.clone(),
                    kind_gate: kind_gate.clone(),
                    kind_bank_gate: kind_bank_gate.clone(),
                    active_gate: active_gate.clone(),
                    drain_prepare: drain_prepare.clone(),
                    release: release.clone(),
                    witness: witness.clone(),
                    content_guard: content_guard.clone(),
                    inputs_recorded: false,
                    model_content_recorded: 0,
                    transition_recorded: 0,
                    drain_recorded: false,
                    observed: false,
                    #[cfg(feature = "semantic-policy")]
                    observed_outcome: None,
                    #[cfg(feature = "semantic-policy")]
                    observed_parent: None,
                    #[cfg(feature = "semantic-policy")]
                    observed_result: None,
                    result,
                    training_origin: training_origins
                        .as_ref()
                        .and_then(|origins| origins.view().try_slice(ordinal..ordinal + 1)),
                    training_view: if *kind == SemanticTransitionKind::Update {
                        Some(
                            training_view
                                .as_ref()
                                .expect("validated update training-view owner")
                                .allocate_selection_reserved(
                                    &mut reservation,
                                    training_origins.clone(),
                                )?,
                        )
                    } else {
                        None
                    },
                    #[cfg(feature = "semantic-policy")]
                    group_vjp_members: [BTreeSet::new(), BTreeSet::new()],
                    #[cfg(feature = "semantic-policy")]
                    group_edit_members: [BTreeSet::new(), BTreeSet::new()],
                    #[cfg(feature = "semantic-policy")]
                    group_imported_vjp_members: [BTreeSet::new(), BTreeSet::new()],
                    #[cfg(feature = "semantic-policy")]
                    group_gradient_members: [BTreeSet::new(), BTreeSet::new()],
                    #[cfg(feature = "semantic-policy")]
                    group_critic_recorded: 0,
                    #[cfg(feature = "semantic-policy")]
                    group_update_published: false,
                    result_kernel: result_kernel.clone(),
                });
                self.steps.insert(handle.token, step);
                let prepared = self.steps[&handle.token]
                    .prepared
                    .as_ref()
                    .expect("installed fixed step");
                // Only immutable catalogue identity is initialized on the host;
                // actual invocation coordinates come from device admission.
                #[cfg(feature = "semantic-policy")]
                for branch in &prepared.branches {
                    upload_publication(
                        &self.provider,
                        &[DeviceState {
                            catalogue_generation: self.binding().generation,
                            catalogue_digest: Identity256::from_bytes(CATALOGUE_DIGEST),
                            binding_digest: self.binding().digest,
                            ..DeviceState::default()
                        }],
                        &branch.state,
                    )?;
                }
                upload_publication(
                    &self.provider,
                    &[PublicationLease::default()],
                    &prepared.reader,
                )?;
                upload_publication(
                    &self.provider,
                    &[PreparedStepResult::default()],
                    &prepared.result,
                )?;
                inputs.initialize(&self.provider)?;
            }
            if reservation.remaining_bytes() != bytes - base_bytes {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            self.training_origins = training_origins;
            Ok(handles)
        })();
        match result {
            Ok(handles) => {
                self.prepared_segment
                    .as_mut()
                    .expect("installed prepared segment")
                    .cold_reservation = Some(reservation);
                Ok(handles)
            }
            Err(error) => {
                self.poisoned = true;
                Err(error)
            }
        }
    }

    fn checked_prepared_step(
        &self,
        step: &SemanticPreparedStep,
        recording: bool,
    ) -> Result<&StepContentStorage, SemanticTransitionError> {
        self.ensure_quiescent()?;
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or_else(|| publication_input_error("Session has no prepared segment"))?;
        if recording {
            build.check(step, &self.publication_issuer, true)?;
        } else {
            build.check_retained(step, &self.publication_issuer)?;
        }
        self.steps
            .get(&step.token)
            .filter(|owner| owner.prepared.is_some() && owner.identity.is_none())
            .ok_or_else(|| {
                publication_input_error("prepared step has no original native storage owner")
            })
    }

    /// Original nominal schedule mode, available only before construction ends.
    /// It does not predict the effective mode selected by device admission.
    pub fn prepared_transition_kind(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<SemanticTransitionKind, SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope");
        build.check(step, &self.publication_issuer, false)?;
        build.requested_kind(step, &self.publication_issuer)
    }

    /// Cold exports retain the original schedule after construction finishes.
    /// This authenticates known completion without reopening graph recording.
    #[cfg(feature = "semantic-policy")]
    fn completed_prepared_transition_kind(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<SemanticTransitionKind, SemanticTransitionError> {
        let owner = self.checked_prepared_step(step, false)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope");
        if !build.completed
            || !owner
                .prepared
                .as_ref()
                .expect("checked prepared owner")
                .observed
        {
            return Err(publication_input_error(
                "completed schedule observation requires this step's known execution",
            ));
        }
        build.requested_kind(step, &self.publication_issuer)
    }

    fn check_prepared_cold(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        if self
            .prepared_segment
            .as_ref()
            .expect("checked build")
            .capturing
        {
            return Err(publication_input_error(
                "fixed resources must be prepared before capture begins",
            ));
        }
        Ok(())
    }

    pub fn prepared_stream(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<Arc<CudaStream>, SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        Ok(Arc::clone(&self.stream))
    }

    /// Reserve private digest storage for original tensors born while recording.
    /// The producer derives this bound from its retained allocation capacity.
    pub fn reserve_tensor_content(
        &mut self,
        step: &SemanticPreparedStep,
        tensor_capacity: usize,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if tensor_capacity == 0 {
            return Err(publication_input_error(
                "content reservation requires a positive original tensor capacity",
            ));
        }
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("content reservation stream admission", error))?;
        if self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .digests
            .is_some()
        {
            return Err(publication_input_error(
                "original content capacity is reserved once per fixed step",
            ));
        }
        let build = self.prepared_segment.as_mut().expect("checked build");
        if tensor_capacity != build.cold_capacity.tensor_content_capacity {
            return Err(publication_input_error(
                "content capacity differs from the frozen segment claim",
            ));
        }
        let cells = build.cold_capacity.content_cells()?;
        let bytes = build.cold_capacity.content_bytes()?;
        let floor = build.cold_capacity.external_floor()?;
        let reservation = build
            .cold_reservation
            .as_mut()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if reservation
            .remaining_bytes()
            .checked_sub(bytes)
            .is_none_or(|remaining| remaining < floor)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let digest = Arc::new(
            reservation
                .alloc::<u64>(cells)
                .map_err(|error| runtime_error("original content allocation", error))?,
        );
        self.steps
            .get_mut(&step.token)
            .expect("checked fixed step")
            .prepared
            .as_mut()
            .expect("checked prepared owner")
            .digests = Some(digest);
        Ok(())
    }

    /// Reserve and allocate the original producer's event roster before capture.
    /// This does not execute the model or upload any recording-time event data.
    pub fn reserve_model_work(
        &mut self,
        step: &SemanticPreparedStep,
        event_capacity: usize,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .model_work
            .is_some()
        {
            return Err(publication_input_error(
                "original model work capacity is reserved once per step",
            ));
        }
        let build = self.prepared_segment.as_ref().expect("checked build");
        if event_capacity != build.cold_capacity.model_work_capacity {
            return Err(publication_input_error(
                "model work capacity differs from the frozen segment claim",
            ));
        }
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("model work reservation stream admission", error))?;
        let bytes = build.cold_capacity.model_work_bytes()?;
        let floor = build.cold_capacity.external_floor()?;
        let work = {
            let reservation = self
                .prepared_segment
                .as_mut()
                .expect("checked build")
                .cold_reservation
                .as_mut()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if reservation
                .remaining_bytes()
                .checked_sub(bytes)
                .is_none_or(|remaining| remaining < floor)
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            PreparedModelWork::allocate(&self.provider, reservation, event_capacity)?
        };
        // Initialize the complete exported scratch allocation cold. Each real
        // producer occurrence additionally records its own reset before use.
        work.reset_slots(&self.domain, &mut self.poisoned, 0, event_capacity)?;
        self.steps
            .get_mut(&step.token)
            .expect("checked original step")
            .prepared
            .as_mut()
            .expect("prepared owner")
            .model_work = Some(work);
        Ok(())
    }

    /// Export the original work scratch as U64[capacity,3] before capture.
    /// Each row is [actual_units, sticky_overflow, producer_writes]. It is not a
    /// canonical receipt or a writable alias of the immutable work descriptors.
    pub fn model_work_buffer(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if consumer_stream != self.stream.cu_stream() as u64 {
            return Err(publication_input_error(
                "model work producers must use the original native recording stream",
            ));
        }
        let work = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .model_work
            .as_ref()
            .ok_or_else(|| publication_input_error("model work requires its cold reservation"))?;
        let capacity = i64::try_from(work.actual.len() / 3)
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        // SAFETY: the entire padding-free U64 scratch bank was initialized by
        // the cold reset; the exported view retains its actual allocation owner.
        let view = unsafe { work.actual.view().cast::<u8>() }
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        self.export_prepared_view(
            step,
            view,
            vec![capacity, 3],
            vec![3, 1],
            (1, 64),
            consumer_stream,
        )
    }

    /// Reserve an occurrence in the current original recording and enqueue its
    /// reset immediately before the producer. A composite operator records one
    /// occurrence per actual unit category, rather than charging a dense mask.
    pub fn record_model_device_work(
        &mut self,
        step: &SemanticPreparedStep,
        kind: ModelWorkKind,
        upper_dimensions: &[u64],
    ) -> Result<usize, SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        let result = (|| {
            let work = self
                .steps
                .get_mut(&step.token)
                .expect("checked original step")
                .prepared
                .as_mut()
                .expect("prepared owner")
                .model_work
                .as_mut()
                .ok_or_else(|| {
                    publication_input_error("model work requires its cold reservation")
                })?;
            let slot = work.next_slot().map_err(publication_input_error)?;
            if slot >= work.actual.len() / 3 {
                return Err(publication_input_error(
                    "model work exceeds its cold event capacity",
                ));
            }
            let actual = work
                .actual
                .device_ptr_value()
                .checked_add((slot * 3 * size_of::<u64>()) as u64)
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            let event = ModelWorkEvent::device_operation(kind, upper_dimensions, actual)
                .map_err(publication_input_error)?;
            let recorded = work.record_event(event).map_err(publication_input_error)?;
            debug_assert_eq!(recorded, slot);
            work.reset_slots(&self.domain, &mut self.poisoned, slot, 1)?;
            Ok(slot)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Append an actual operator occurrence during the original first recording.
    /// Geometry is expressed in the agreed unit (coordinates, summands or bytes),
    /// not FLOPs, elapsed time, or a caller-computed aggregate cost.
    pub fn record_model_work(
        &mut self,
        step: &SemanticPreparedStep,
        kind: ModelWorkKind,
        dimensions: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        let result = (|| {
            let event =
                ModelWorkEvent::operation(kind, dimensions).map_err(publication_input_error)?;
            let work = self
                .steps
                .get_mut(&step.token)
                .expect("checked original step")
                .prepared
                .as_mut()
                .expect("prepared owner")
                .model_work
                .as_mut()
                .ok_or_else(|| {
                    publication_input_error("model work requires its original cold reservation")
                })?;
            work.record_event(event)
                .map(|_| ())
                .map_err(publication_input_error)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Record at the original model-call site, within its active bank capture.
    /// A marker executes only in the selected graph, not once per cold capture.
    pub fn record_model_invocation(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        let result = self
            .steps
            .get_mut(&step.token)
            .expect("checked original step")
            .prepared
            .as_mut()
            .expect("prepared owner")
            .model_work
            .as_mut()
            .ok_or_else(|| {
                publication_input_error(
                    "model invocation requires its original cold work reservation",
                )
            })?
            .record_invocation(&self.domain, &mut self.poisoned);
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Charge each original saved clone from its retained native tensor layout.
    /// A repeated storage still costs another copy when a new witness records
    /// another save occurrence. Reusing the same occurrence is rejected.
    pub fn record_saved_tensor_work(
        &mut self,
        step: &SemanticPreparedStep,
        witness: &SemanticTensorContentWitness,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        let result = (|| {
            let owner = self
                .steps
                .get_mut(&step.token)
                .expect("checked original step");
            if !Arc::ptr_eq(&witness.issuer, &self.publication_issuer)
                || witness.reader_token != step.token
                || !Arc::ptr_eq(&witness._witness, &owner.content_witnesses)
            {
                return Err(publication_input_error(
                    "saved work requires this original step and tensor witness",
                ));
            }
            let content = owner.content.get(witness.index).ok_or_else(|| {
                publication_input_error("saved work has no retained original tensor occurrence")
            })?;
            let work = owner
                .prepared
                .as_mut()
                .expect("prepared owner")
                .model_work
                .as_mut()
                .ok_or_else(|| {
                    publication_input_error("saved work requires its original cold reservation")
                })?;
            for (index, tensor) in content.tensors.iter().enumerate() {
                let layout = &tensor.layout;
                let dimensions = layout
                    .dimensions
                    .get(..layout.rank as usize)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let event = ModelWorkEvent::saved(
                    witness.index as u64,
                    index as u64,
                    dimensions,
                    layout.element_bytes,
                )
                .map_err(publication_input_error)?;
                work.record_event(event).map_err(publication_input_error)?;
            }
            Ok(())
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    fn export_prepared_view(
        &mut self,
        step: &SemanticPreparedStep,
        view: DeviceMemoryView<u8>,
        shape: Vec<i64>,
        strides: Vec<i64>,
        dtype: (u8, u8),
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        let guard = Arc::clone(&self.steps[&step.token].aliases);
        self.steps
            .get_mut(&step.token)
            .expect("checked fixed step")
            .consumer_streams
            .insert(consumer_stream);
        self.export_owned_view(view, shape, strides, dtype, guard, consumer_stream)
    }

    pub fn prepared_source(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        let (_, shape, strides) = PublicationBankField::Source.layout();
        let view = self.steps[&step.token]
            .inputs
            .as_ref()
            .expect("fixed input owner")
            .field_view(PublicationBankField::Source)?;
        self.export_prepared_view(step, view, shape, strides, (1, 64), consumer_stream)
    }

    pub fn prepared_prefix(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.prepared_tensor(
            step,
            SemanticStateRole::PrefixSource,
            0,
            bank,
            consumer_stream,
        )
    }

    pub fn prepared_record(
        &mut self,
        step: &SemanticPreparedStep,
        role: SemanticStateRole,
        index: u64,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if is_tensor_role(role as u64) {
            return Err(publication_input_error(
                "tensor roles require their original model layout",
            ));
        }
        if role == SemanticStateRole::PrefixSource {
            return Err(publication_input_error(
                "prepared prefixes require the fixed typed capacity and original device extent",
            ));
        }
        let storage = self.publication.as_ref().expect("prepared publication");
        let key = (role as u64, index);
        let inputs = self.steps[&step.token]
            .inputs
            .as_ref()
            .expect("fixed inputs");
        let view = if let Some(view) = inputs.views[0].get(&key) {
            view.clone()
        } else {
            let original = storage.bank_templates[0]
                .iter()
                .find(|range| (range.role, range.index) == key)
                .ok_or_else(|| {
                    publication_input_error("record has no original fixed declaration")
                })?;
            let other = storage.bank_templates[1]
                .iter()
                .find(|range| (range.role, range.index) == key)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if publication_mutable_role(role as u64)
                || original.storage_slot != other.storage_slot
                || original.offset_bytes != other.offset_bytes
                || original.length_bytes != other.length_bytes
            {
                return Err(publication_input_error(
                    "bank-varying records require a private prepared input producer",
                ));
            }
            let begin = original.offset_bytes as usize;
            let end = begin
                .checked_add(original.length_bytes as usize)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            storage.allocations[original.storage_slot as usize]
                .view()
                .slice(begin..end)
        };
        let bytes =
            i64::try_from(view.len()).map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        self.export_prepared_view(step, view, vec![bytes], vec![1], (1, 8), consumer_stream)
    }

    pub fn prepared_range_keys(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<Vec<(SemanticStateRole, u64)>, SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        self.publication
            .as_ref()
            .expect("prepared publication")
            .bank_templates[0]
            .iter()
            .map(|range| {
                SemanticStateRole::from_code(range.role)
                    .map(|role| (role, range.index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)
            })
            .collect()
    }

    /// Export the fixed original capacity; live extents remain device inputs.
    pub fn prepared_tensor(
        &mut self,
        step: &SemanticPreparedStep,
        role: SemanticStateRole,
        index: u64,
        bank: usize,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        let (view, layout) = self.prepared_tensor_view(step, role, index, bank)?;
        let shape = layout.dimensions[..layout.rank as usize]
            .iter()
            .map(|&value| {
                i64::try_from(value).map_err(|_| SemanticTransitionError::ObservationMismatch)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let strides = layout.strides_bytes[..layout.rank as usize]
            .iter()
            .map(|&value| {
                i64::try_from(value / layout.element_bytes)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)
            })
            .collect::<Result<Vec<_>, _>>()?;
        let dtype = match layout.scalar_type {
            1 => (1, 8),
            2 => (1, 32),
            3 => (1, 64),
            4 => (2, 16),
            5 => (4, 16),
            6 => (2, 32),
            7 => (0, 64),
            8 => (6, 8),
            9 => (2, 64),
            _ => return Err(SemanticTransitionError::ObservationMismatch),
        };
        self.export_prepared_view(step, view, shape, strides, dtype, consumer_stream)
    }

    /// Export one fixed device port produced by this Update step's native
    /// selection. Its status word remains device-resident and gates consumers.
    pub fn prepared_training_view_port(
        &mut self,
        step: &SemanticPreparedStep,
        port: SemanticTrainingViewPort,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if self.prepared_transition_kind(step)? != SemanticTransitionKind::Update {
            return Err(publication_input_error(
                "native selected training views belong only to prepared updates",
            ));
        }
        let (view, shape, strides, dtype) = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .training_view
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?
            .port(port)?;
        self.export_prepared_view(step, view, shape, strides, dtype, consumer_stream)
    }

    /// Actual allocation origin and complete backing bytes of the fixed view
    /// exported by `prepared_tensor`. The byte export retains the original step
    /// grant and stream ordering. Live extents and version counters are separate.
    pub fn prepared_tensor_allocation(
        &mut self,
        step: &SemanticPreparedStep,
        role: SemanticStateRole,
        index: u64,
        bank: usize,
        consumer_stream: u64,
    ) -> Result<(DeviceAllocationProvenance, DlpackManagedTensor), SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        let (view, _) = self.prepared_tensor_view(step, role, index, bank)?;
        let provenance = view.allocation_provenance().ok_or_else(|| {
            publication_input_error("prepared tensor has no complete native allocation owner")
        })?;
        let allocation = view
            .allocation_view()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let bytes = i64::try_from(allocation.len())
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let tensor = self.export_prepared_view(
            step,
            allocation,
            vec![bytes],
            vec![1],
            (1, 8),
            consumer_stream,
        )?;
        Ok((provenance, tensor))
    }

    fn prepared_tensor_view(
        &mut self,
        step: &SemanticPreparedStep,
        role: SemanticStateRole,
        index: u64,
        bank: usize,
    ) -> Result<(DeviceMemoryView<u8>, SemanticTensorLayout), SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared tensor bank must be zero or one",
            ));
        }
        let retained = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope")
            .finished;
        if retained {
            let actual_bank = self.prepared_completed_parent_bank(step.token)?;
            if actual_bank != bank {
                return Err(publication_input_error(
                    "completed tensor requires the original executed branch bank",
                ));
            }
        }
        let inputs = self.steps[&step.token]
            .inputs
            .as_ref()
            .expect("fixed input owner");
        let plan = inputs
            .plans
            .iter()
            .find(|plan| (plan.role, plan.index) == (role as u64, index))
            .ok_or_else(|| {
                publication_input_error("prepared tensor has no fixed original input owner")
            })?;
        let custody = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("checked prepared owner")
            .replay_custody
            .as_ref();
        let view = if let Some(custody) =
            custody.filter(|_| retained && matches!(role as u64, 1 | 4 | 5 | 18..=25))
        {
            custody.input_view(role as u64, index)?.0
        } else {
            inputs.views[bank][&(role as u64, index)].clone()
        };
        Ok((view, plan.layout))
    }

    pub fn prepared_terminal(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.prepared_bank_field(step, PublicationBankField::Terminal, consumer_stream)
    }

    pub fn prepared_prefix_extent(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.prepared_bank_field(step, PublicationBankField::PrefixExtent, consumer_stream)
    }

    pub fn prepared_ring_head(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.prepared_bank_field(step, PublicationBankField::RingHead, consumer_stream)
    }

    fn prepared_bank_field(
        &mut self,
        step: &SemanticPreparedStep,
        field: PublicationBankField,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        let inputs = self.steps[&step.token]
            .inputs
            .as_ref()
            .expect("prepared input owner");
        let (_, shape, strides) = field.layout();
        self.export_prepared_view(
            step,
            inputs.field_view(field)?,
            shape,
            strides,
            (1, 64),
            consumer_stream,
        )
    }

    /// Immutable admitted model geometry; no future publication values occur.
    pub fn prepared_model_geometry(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<(Identity256, Identity256, u64, u64, u64, u64), SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        let contract = self
            .publication
            .as_ref()
            .expect("prepared publication")
            .contract_value;
        Ok((
            contract.topology_identity,
            contract.table_identity,
            contract.model_generation,
            contract.prefix_capacity,
            contract.feedback_capacity,
            contract.max_position,
        ))
    }

    /// Authenticate the retained model inputs of an actually completed step.
    /// This cold observation joins every original consumer before checking the
    /// private input seals and reading that step's actual acquisition/result.
    /// It never acquires a current bank or constructs a historical live reader.
    ///
    /// Returns (predecessor, successor-or-None, model generation, model geometry
    /// digest, model numerical digest). A numerical refusal has no successor;
    /// skipped steps and unknown completion have no observable input binding.
    /// Model record 44 and complete model backing allocations are the existing
    /// prepared record/tensor exports, retained until original step retirement.
    /// Recheck this binding after serializing those read-only exports. This is
    /// not complete semantic replay material or authority for another forward.
    pub fn prepared_model_binding(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<
        (
            SemanticPublishedIdentity,
            Option<SemanticPublishedIdentity>,
            u64,
            Identity256,
            Identity256,
        ),
        SemanticTransitionError,
    > {
        let owner = self.checked_prepared_step(step, false)?;
        let prepared = owner.prepared.as_ref().expect("checked prepared owner");
        if !self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope")
            .completed
            || !prepared.observed
        {
            return Err(publication_input_error(
                "model input observation requires this step's known completed execution",
            ));
        }
        let inputs = Arc::clone(
            owner
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?,
        );
        let reader = prepared.reader.view();
        let result = prepared.result.view();
        let _ordinary =
            crate::cuda_graph::reserve_uncaptured_stream(&self.stream).map_err(|error| {
                runtime_error("completed model observation stream admission", error)
            })?;
        self.complete_step_consumers_by_token(step.token, consumer_streams)?;
        let custody = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("checked prepared owner")
            .replay_custody
            .as_ref();
        inputs.verify_completed(&self.domain, &mut self.poisoned, custody)?;
        let parent = self.publication_read(inputs.header.view())?[0];
        let reader = self.publication_read(reader)?[0];
        let result = self.publication_read(result)?[0];
        if validate_prepared_completion(&reader, &parent, &result, inputs.storage.instance).is_err()
            || (result.advanced == 0 && result.header != parent)
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let identity = |header: PublicationHeader| SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        };
        Ok((
            identity(parent),
            (result.advanced == 1).then(|| identity(result.header)),
            parent.model_generation,
            parent.model_geometry_digest,
            parent.model_numerical_digest,
        ))
    }

    /// Joined execution quantities for this original step, including known
    /// skips and refusals. These exclude cold preparation and are not a whole
    /// resource-unit or physical memory certificate. Overflow is not a value.
    #[cfg(feature = "semantic-policy")]
    pub fn prepared_execution_measurements(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<SemanticCompletedExecutionObservation, SemanticTransitionError> {
        let original = self.checked_prepared_step(step, false)?;
        if !self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope")
            .completed
        {
            return Err(publication_input_error(
                "execution measurements require the original segment's known completion",
            ));
        }
        let prepared = original.prepared.as_ref().expect("checked original step");
        let requested_transition = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope")
            .requested_kind(step, &self.publication_issuer)?;
        let original_outcome = prepared
            .observed_outcome
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .clone();
        let original_parent = prepared.observed_parent;
        let original_result = prepared.observed_result;
        let reader = prepared.reader.view();
        let result = prepared.result.view();
        let mut streams = original.consumer_streams.clone();
        if let Some(reader) = self.readers.get(&step.token) {
            streams.extend(reader.consumer_streams.iter().copied());
        }
        let observation = (|| {
            self.complete_step_consumers_by_token(
                step.token,
                &streams.into_iter().collect::<Vec<_>>(),
            )?;
            let lease = self.publication_read(reader)?[0];
            let result = self.publication_read(result)?[0];
            let prepared = self.steps[&step.token]
                .prepared
                .as_ref()
                .expect("retained original step");
            let work = prepared
                .model_work
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let actual = work.actual.view();
            let actual = self.publication_read(actual)?;
            if result.abi == 0 {
                if lease.active != 0
                    || lease.abi != 0
                    || lease.transition_kind != 0
                    || !matches!(lease.status, 1..=5 | 7)
                    || original_parent.is_some()
                    || original_result.is_some()
                    || !matches!(&original_outcome,
                        SemanticPreparedStepOutcome::Skipped { step: issued, status }
                            if issued.same_handle(step) && *status == lease.status)
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                self.steps[&step.token]
                    .prepared
                    .as_ref()
                    .expect("retained original step")
                    .model_work
                    .as_ref()
                    .expect("original work checked above")
                    .completed_model_calls(&actual, false)?;
                return Ok(SemanticCompletedExecutionObservation {
                    original: step.clone(),
                    requested_transition,
                    outcome: original_outcome,
                    predecessor: None,
                    successor: None,
                    model_binding: None,
                    quantities: [0; 4],
                });
            }
            let parent = self.steps[&step.token]
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?
                .header
                .view();
            let parent = self.publication_read(parent)?[0];
            let transition =
                validate_prepared_completion(&lease, &parent, &result, parent.instance)?;
            if original_parent != Some(parent)
                || original_result != Some(result)
                || !matches!(&original_outcome,
                    SemanticPreparedStepOutcome::Completed {
                        step: issued, bank, transition: issued_transition, ..
                    } if issued.same_handle(step)
                        && u64::from(*bank) == lease.bank
                        && *issued_transition == transition)
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let prepared = self.steps[&step.token]
                .prepared
                .as_ref()
                .expect("retained original step");
            if !prepared.observed {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let state = prepared
                .branches
                .get(
                    usize::try_from(lease.bank)
                        .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
                )
                .ok_or(SemanticTransitionError::ObservationMismatch)?
                .state
                .view();
            let state = self.publication_read(state)?[0];
            let work = state.execution_work;
            if work.overflow != 0
                || work.model_once.checked_add(work.native_attempt) != Some(work.raw)
                || (transition != SemanticTransitionKind::Drain
                    && !work.validate_model(
                        &self.steps[&step.token]
                            .prepared
                            .as_ref()
                            .expect("retained original step")
                            .model_work
                            .as_ref()
                            .expect("original work checked above")
                            .recording,
                        false,
                    ))
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let calls = self.steps[&step.token]
                .prepared
                .as_ref()
                .expect("retained original step")
                .model_work
                .as_ref()
                .expect("original work checked above")
                .completed_model_calls(&actual, transition != SemanticTransitionKind::Drain)?;
            let identity = |header: PublicationHeader| SemanticPublishedIdentity {
                instance: header.instance,
                word: header.publication_word,
                logical_digest: header.logical_digest,
                state_digest: header.state_digest,
            };
            Ok(SemanticCompletedExecutionObservation {
                original: step.clone(),
                requested_transition,
                outcome: original_outcome,
                predecessor: Some(identity(parent)),
                successor: (result.advanced == 1).then(|| identity(result.header)),
                model_binding: Some((
                    parent.model_generation,
                    parent.model_geometry_digest,
                    parent.model_numerical_digest,
                )),
                quantities: [work.raw, work.model_once, work.native_attempt, calls],
            })
        })();
        if observation.is_err() {
            self.poisoned = true;
        }
        observation
    }

    /// Read the original five Update checks and original forward receipts after
    /// terminal completion. All returned data is host-owned; no reader is acquired
    /// and no forward, metric, or candidate generation is reconstructed.
    #[cfg(feature = "semantic-policy")]
    pub fn prepared_update_measurements(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<Option<SemanticUpdateMeasurements>, SemanticTransitionError> {
        let original = self.checked_prepared_step(step, false)?;
        let mut streams = original.consumer_streams.clone();
        if let Some(reader) = self.readers.get(&step.token) {
            streams.extend(reader.consumer_streams.iter().copied());
        }
        let streams = streams.into_iter().collect::<Vec<_>>();
        let binding = self.prepared_model_binding(step, &streams)?;
        let observation = (|| {
            let prepared = self.steps[&step.token]
                .prepared
                .as_ref()
                .expect("checked owner");
            let lease_view = prepared.reader.view();
            let result_view = prepared.result.view();
            let parent_view = self.steps[&step.token]
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?
                .header
                .view();
            let parent = self.publication_read(parent_view)?[0];
            let lease = self.publication_read(lease_view)?[0];
            let result = self.publication_read(result_view)?[0];
            let transition =
                validate_prepared_completion(&lease, &parent, &result, parent.instance)?;
            if transition != SemanticTransitionKind::Update {
                return Ok(None);
            }
            let bank = usize::try_from(lease.bank)
                .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
            let (
                selection,
                canaries,
                rows,
                protected,
                results,
                receipts,
                refusal,
                state,
                logits,
                work_count,
            ) = {
                let prepared = self.steps[&step.token]
                    .prepared
                    .as_ref()
                    .expect("checked owner");
                let view = prepared
                    .training_view
                    .as_ref()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let branch = prepared
                    .branches
                    .get(bank)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let update = branch
                    .model_update
                    .as_ref()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let output = update
                    .output
                    .as_ref()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let work = prepared
                    .model_work
                    .as_ref()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                (
                    view.selection(),
                    view.canaries(),
                    view.roster_rows(),
                    view.protected_members(),
                    update.canary_results.view(),
                    update.forward_receipts.view(),
                    update.refusal.view(),
                    branch.state.view(),
                    [
                        (output.baseline_logits.data, output.baseline_logits.layout),
                        (output.candidate_logits.data, output.candidate_logits.layout),
                    ],
                    work.recording.events().len() as u64,
                )
            };
            let selection = self.publication_read(selection)?[0];
            let canaries = self.publication_read(canaries)?;
            let rows = self.publication_read(rows)?;
            let protected = self.publication_read(protected)?;
            let results = self.publication_read(results)?;
            let receipts = self.publication_read(receipts)?;
            let refusal = decode_canary_refusal(self.publication_read(refusal)?[0], &results)?;
            let state = self.publication_read(state)?[0];
            if canaries.len() != 5
                || results.len() != 5
                || receipts.len() != 2
                || selection.status > 3
                || selection.row_count != rows.len() as u64
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let mut observations = Vec::with_capacity(5);
            for (index, (frozen, measured)) in canaries.into_iter().zip(&results).enumerate() {
                let row = rows
                    .get(
                        usize::try_from(frozen.row_ordinal)
                            .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
                    )
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let lower = f64::from_bits(frozen.lower_bound_bits);
                let upper = f64::from_bits(frozen.upper_bound_bits);
                let value = f64::from_bits(measured.measurement_bits);
                let complete = measured.availability == 2;
                let reason_valid = match measured.reason {
                    0 => {
                        complete
                            && value.is_finite()
                            && value >= lower
                            && value <= upper
                            && measured.memory_used <= frozen.memory_limit
                            && measured.work_used <= frozen.work_limit
                    }
                    1 => measured.availability == 1 || (complete && !value.is_finite()),
                    2 => complete && value.is_finite() && (value < lower || value > upper),
                    3 => complete && measured.memory_used > frozen.memory_limit,
                    4 => measured.work_used > frozen.work_limit,
                    5 => !complete,
                    6 => complete && frozen.kind == 2,
                    7 => {
                        (measured.availability == 1 && matches!(frozen.kind, 1 | 4))
                            || (complete && frozen.kind == 4)
                    }
                    8 => true,
                    9 => measured.availability == 0,
                    _ => false,
                };
                if frozen.evaluator_abi != 3
                    || frozen.kind != index as u64 + 1
                    || frozen.task_identity
                        != identity_words(
                            *self
                                .publication
                                .as_ref()
                                .expect("checked publication")
                                .contract_value
                                .task_identity
                                .as_bytes(),
                        )
                    || row.ordinal != frozen.row_ordinal
                    || row.identity != frozen.row_identity
                    || row.content_identity != frozen.row_content_identity
                    || measured.abi != 1
                    || measured.kind != frozen.kind
                    || measured.row_ordinal != frozen.row_ordinal
                    || measured.identity != frozen.identity
                    || measured.availability > 2
                    || !reason_valid
                    || !lower.is_finite()
                    || !upper.is_finite()
                    || lower > upper
                    || frozen.memory_limit == 0
                    || frozen.work_limit == 0
                    || measured.memory_used != results[0].memory_used
                    || measured.work_used != results[0].work_used
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                let begin = usize::try_from(frozen.protected_member_offset)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
                let count = usize::try_from(frozen.protected_member_count)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
                let end = begin
                    .checked_add(count)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let positions = protected
                    .get(begin..end)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?
                    .to_vec();
                observations.push(SemanticUpdateCanaryMeasurement {
                    frozen,
                    protected_positions: positions,
                    availability: measured.availability,
                    reason: measured.reason,
                    measurement_bits: complete.then_some(measured.measurement_bits),
                    memory_used: measured.memory_used,
                    work_used: measured.work_used,
                });
            }
            let winning = results
                .iter()
                .filter(|check| check.reason != 0)
                .min_by_key(|check| (check.reason, check.kind));
            if winning.map(|check| (check.reason, check.kind))
                != refusal.map(|record| (record.reason, record.kind))
                || refusal.is_some_and(|record| {
                    let frozen = &observations[(record.kind - 1) as usize].frozen;
                    record.selection_identity != selection.identity
                        || record.lower_bound_bits != frozen.lower_bound_bits
                        || record.upper_bound_bits != frozen.upper_bound_bits
                        || record.memory_limit != frozen.memory_limit
                        || record.work_limit != frozen.work_limit
                })
                || (result.advanced == 1
                    && (state.status != 0
                        || refusal.is_some()
                        || observations.iter().any(|check| check.availability != 2)))
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let mut forwards = Vec::with_capacity(2);
            for (role, receipt) in receipts.iter().enumerate() {
                if receipt.availability > 2 {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                let bytes = receipt.canonical_bytes();
                let material = if receipt.availability == 2 {
                    let (address, layout) = logits[role];
                    let digest: [u8; 32] = Sha256::digest(&bytes[..bytes.len() - 32]).into();
                    if receipt.abi != 1
                        || receipt.role != role as u64
                        || receipt.work_sequence == 0
                        || receipt.work_sequence > work_count
                        || receipt.logits != address
                        || receipt.scalar_type != layout.scalar_type
                        || [receipt.row_count, receipt.capacity, receipt.vocabulary]
                            != layout.dimensions[..3]
                        || receipt.strides_bytes != layout.strides_bytes[..3]
                        || receipt.model_geometry_digest != binding.3
                        || receipt.identity != Identity256::from_bytes(digest)
                        || receipt.model_numerical_digest == Identity256::default()
                        || (role == 0
                            && (receipt.generation != binding.2
                                || receipt.model_numerical_digest != binding.4))
                        || (role == 1
                            && result.advanced == 1
                            && (receipt.generation != result.header.model_generation
                                || receipt.model_numerical_digest
                                    != result.header.model_numerical_digest))
                    {
                        return Err(SemanticTransitionError::ObservationMismatch);
                    }
                    Some(SemanticUpdateForwardReceiptMaterial {
                        role: receipt.role,
                        generation: receipt.generation,
                        work_sequence: receipt.work_sequence,
                        scalar_type: receipt.scalar_type,
                        dimensions: [receipt.row_count, receipt.capacity, receipt.vocabulary],
                        strides_bytes: receipt.strides_bytes,
                        model_geometry_digest: receipt.model_geometry_digest,
                        model_numerical_digest: receipt.model_numerical_digest,
                        logits_digest: receipt.logits_digest,
                        identity: receipt.identity,
                        canonical_bytes: bytes,
                    })
                } else {
                    // An unexecuted one-shot receipt is the original zero allocation.
                    // A started but incomplete producer cannot masquerade as a sealed receipt.
                    let mut absent = *receipt;
                    absent.availability = 0;
                    if absent.canonical_bytes().iter().any(|&byte| byte != 0)
                        || result.advanced == 1
                    {
                        return Err(SemanticTransitionError::ObservationMismatch);
                    }
                    None
                };
                forwards.push(SemanticUpdateForwardReceipt {
                    availability: receipt.availability,
                    material,
                });
            }
            if receipts.iter().all(|receipt| receipt.availability == 2)
                && (receipts[0].work_sequence >= receipts[1].work_sequence
                    || receipts[0].identity == receipts[1].identity)
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            Ok(Some(SemanticUpdateMeasurements {
                predecessor: binding.0,
                successor: binding.1,
                bank: bank as u8,
                model_generation: binding.2,
                model_geometry_digest: binding.3,
                model_numerical_digest: binding.4,
                transition_status: state.status,
                selection,
                canaries: observations,
                forward_receipts: forwards
                    .try_into()
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
                canary_refusal: refusal,
            }))
        })();
        if observation.is_err() {
            self.poisoned = true;
        }
        let observation = observation?;
        if self.prepared_model_binding(step, &streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(observation)
    }

    pub fn prepared_feedback(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<(SemanticFeedbackSchema, [DlpackManagedTensor; 6]), SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        let feedback = &self.steps[&step.token].feedback[0];
        let schema = feedback.schema.clone();
        let layouts = feedback
            .content
            .tensors
            .iter()
            .map(|tensor| {
                (
                    tensor.source.as_ref().expect("feedback owner").clone(),
                    tensor.layout,
                )
            })
            .collect::<Vec<_>>();
        let mut outputs = Vec::with_capacity(6);
        for (view, layout) in layouts {
            let shape = layout.dimensions[..layout.rank as usize]
                .iter()
                .map(|&value| value as i64)
                .collect();
            let strides = layout.strides_bytes[..layout.rank as usize]
                .iter()
                .map(|&value| (value / layout.element_bytes) as i64)
                .collect();
            let dtype = match layout.scalar_type {
                3 => (1, 64),
                6 => (2, 32),
                8 => (6, 8),
                _ => return Err(SemanticTransitionError::ObservationMismatch),
            };
            outputs.push(self.export_prepared_view(
                step,
                view,
                shape,
                strides,
                dtype,
                consumer_stream,
            )?);
        }
        Ok((
            schema,
            outputs
                .try_into()
                .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
        ))
    }

    /// Cold readback of each original raw feedback, statement and provenance
    /// record, after known completion and before this prepared step retires.
    /// The original input guard brackets readback; neither a current-bank
    /// reader nor a fresh encoder/semantic query is constructed. These bytes
    /// are inputs to the canonical carrier, not an execution or replay grant.
    pub fn prepared_feedback_records(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<
        (
            SemanticPublishedIdentity,
            Option<SemanticPublishedIdentity>,
            Vec<SemanticFeedbackRecordMaterial>,
        ),
        SemanticTransitionError,
    > {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        let inputs = Arc::clone(
            self.checked_prepared_step(step, false)?
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?,
        );
        let ranges = self.publication_read(inputs.ranges.view())?;
        let mut records = Vec::new();
        for range in ranges
            .into_iter()
            .filter(|range| matches!(range.role, 15..=17))
        {
            let original = inputs
                .storage
                .allocations
                .get(
                    usize::try_from(range.storage_slot)
                        .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
                )
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let capacity = usize::try_from(range.offset_bytes)
                .ok()
                .and_then(|begin| original.len().checked_sub(begin))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let view = inputs
                .views
                .first()
                .expect("two publication input banks")
                .get(&(range.role, range.index))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let bytes = self.publication_read(view.clone())?;
            match (PublicationMaterialRange {
                range,
                capacity,
                bytes,
            })
            .into_feedback_record()
            {
                Ok(record) => records.push(record),
                Err(error) => {
                    self.poisoned = true;
                    return Err(error);
                }
            }
        }
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok((binding.0, binding.1, records))
    }

    /// Serialize the completed step's original native RNG and executed-work
    /// witnesses while its retained input/result owners are still reachable.
    #[cfg(feature = "semantic-policy")]
    fn prepared_completed_step_witnesses(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<SemanticCompletedStepWitnessMaterial, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        let transition = match self.completed_prepared_transition_kind(step)? {
            SemanticTransitionKind::Proposal => 1,
            SemanticTransitionKind::Recompute => 2,
            SemanticTransitionKind::Update => 3,
            SemanticTransitionKind::Drain => 4,
        };
        let (header_view, result_view, actual_view, events) = {
            let owner = self.checked_prepared_step(step, false)?;
            let inputs = owner
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let prepared = owner.prepared.as_ref().expect("checked prepared owner");
            let work = prepared
                .model_work
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            (
                inputs.header.view(),
                prepared.result.view(),
                work.actual.view(),
                work.recording.events().to_vec(),
            )
        };
        let header = self.publication_read(header_view)?[0];
        let result = self.publication_read(result_view)?[0];
        let actual = self.publication_read(actual_view)?;
        if actual.len() < events.len().saturating_mul(3) {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }

        let mut owner_binding = Vec::new();
        owner_binding.extend_from_slice(b"xlog.completed-step-witness-owner.v1\0");
        encode_publication_identity(&mut owner_binding, binding.0);
        material_u64(&mut owner_binding, u64::from(binding.1.is_some()));
        if let Some(successor) = binding.1 {
            encode_publication_identity(&mut owner_binding, successor);
        }
        material_u64(&mut owner_binding, step.token);
        material_u64(&mut owner_binding, transition);
        let mut owner_hash = Sha256::new();
        owner_hash.update(&owner_binding);
        let identity = Identity256::from_bytes(owner_hash.finalize().into());

        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-COMPLETED-STEP-WITNESSES\0");
        material_u64(&mut bytes, 1);
        material_u64(&mut bytes, transition);
        encode_publication_identity(&mut bytes, binding.0);
        material_u64(&mut bytes, u64::from(binding.1.is_some()));
        if let Some(successor) = binding.1 {
            encode_publication_identity(&mut bytes, successor);
        }
        material_u64(&mut bytes, header.model_generation);
        material_u64(&mut bytes, header.stream_serial);
        material_u64(&mut bytes, header.family_id);
        material_u64(&mut bytes, header.proposal);
        material_u64(&mut bytes, header.training_cursor);
        for value in header.training_rng {
            material_u64(&mut bytes, value);
        }
        material_u64(&mut bytes, result.refusal);
        material_u64(&mut bytes, result.advanced);
        bytes.extend_from_slice(binding.3.as_bytes());
        bytes.extend_from_slice(binding.4.as_bytes());
        material_u64(&mut bytes, events.len() as u64);
        for (index, event) in events.iter().enumerate() {
            material_u64(&mut bytes, event.kind);
            material_u64(&mut bytes, event.witness);
            material_u64(&mut bytes, event.tensor);
            material_u64(&mut bytes, event.rank);
            for dimension in event.dimensions {
                material_u64(&mut bytes, dimension);
            }
            for value in &actual[index * 3..index * 3 + 3] {
                material_u64(&mut bytes, *value);
            }
        }
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticCompletedStepWitnessMaterial { identity, bytes })
    }

    /// Serialize the selected Proposal branch's original device state and all
    /// 136 exact component receipts after known completion. The step-owned
    /// buffers, not a current publication or Python reconstruction, are read.
    #[cfg(feature = "semantic-policy")]
    fn prepared_completed_action_witnesses(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<SemanticCompletedStepWitnessMaterial, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        if self.completed_prepared_transition_kind(step)? != SemanticTransitionKind::Proposal {
            return Err(publication_input_error(
                "completed action witnesses require an original Proposal",
            ));
        }
        let result_view = self
            .checked_prepared_step(step, false)?
            .prepared
            .as_ref()
            .expect("checked prepared owner")
            .result
            .view();
        let result = self.publication_read(result_view)?[0];
        let tape_index = self.completed_prepared_policy_tape(step)?;
        let bank = self.policy_tapes[tape_index]
            .prepared_bank
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let (state_view, receipt_view) = {
            let prepared = self
                .checked_prepared_step(step, false)?
                .prepared
                .as_ref()
                .expect("checked prepared owner");
            let branch = &prepared.branches[bank];
            (
                branch.state.view(),
                self.policy_tapes[tape_index].receipts.view(),
            )
        };
        let state = self.publication_read(state_view)?[0];
        let receipts = self.publication_read(receipt_view)?;
        if result.refusal != 0
            || result.advanced != 1
            || state.status != 0
            || state.blocks != COMPONENT_COUNT as u64
            || receipts.len() != COMPONENT_COUNT
            || state.proposal.checked_add(1) != Some(state.next_proposal)
            || state.next_proposal != result.header.proposal
            || receipts
                .iter()
                .any(|receipt| receipt.proposal != state.proposal)
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }

        let mut owner_binding = Vec::new();
        owner_binding.extend_from_slice(b"xlog.completed-action-witness-owner.v1\0");
        encode_publication_identity(&mut owner_binding, binding.0);
        encode_publication_identity(
            &mut owner_binding,
            binding
                .1
                .ok_or(SemanticTransitionError::ObservationMismatch)?,
        );
        material_u64(&mut owner_binding, step.token);
        material_u64(&mut owner_binding, state.proposal);
        let mut owner_hash = Sha256::new();
        owner_hash.update(&owner_binding);
        let identity = Identity256::from_bytes(owner_hash.finalize().into());

        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-COMPLETED-ACTION-WITNESSES\0");
        material_u64(&mut bytes, 1);
        encode_publication_identity(&mut bytes, binding.0);
        encode_publication_identity(
            &mut bytes,
            binding
                .1
                .ok_or(SemanticTransitionError::ObservationMismatch)?,
        );
        material_u64(&mut bytes, bank as u64);
        material_u64(&mut bytes, size_of::<DeviceState>() as u64);
        bytes.extend(publication_abi_bytes(&[state]));
        material_u64(&mut bytes, receipts.len() as u64);
        bytes.extend(publication_abi_bytes(&receipts));
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticCompletedStepWitnessMaterial { identity, bytes })
    }

    #[cfg(feature = "semantic-policy")]
    fn original_initial_prefill_content(
        &mut self,
        predecessor: SemanticPublishedIdentity,
        semantic_root: Identity256,
        prefix_extent: u64,
        model_generation: u64,
        task_identity: Identity256,
        task_content: SemanticTaskContentIdentity,
    ) -> Result<Option<Vec<u8>>, SemanticTransitionError> {
        let Some(retained) = self.retained_initial_prefill.as_ref() else {
            return Ok(None);
        };
        if retained.record.predecessor != predecessor {
            return Ok(None);
        }
        let record = retained.record.clone();
        if record.semantic_root != semantic_root
            || record.model_generation != model_generation
            || record.task_identity != task_identity
            || record.task_content != task_content
            || record.task_epoch != self.task_epoch
            || record.task_identity != retained.task_identity
            || record.task_epoch != retained.task_epoch
            || record.model_generation != retained.model_generation
            || record.tokens.is_empty()
            || record.tokens.len() as u64 != prefix_extent
            || record.mapping.len() != record.tokens.len()
            || record.mapping.iter().enumerate().any(|(position, row)| {
                row.source.is_empty() || row.logical_position != position as u64
            })
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let model_seals = initial_prefill_seal_sources(&retained.model)?;
        let output_seals = initial_prefill_seal_sources(&retained.output)?;
        if model_seals.is_empty()
            || output_seals.is_empty()
            || model_seals
                .iter()
                .any(|(role, _, _, _)| !matches!(role, 0 | 18..=25))
            || output_seals
                .iter()
                .any(|(role, _, _, _)| !matches!(role, 4..=13))
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let mut bytes = Vec::new();
        bytes.extend_from_slice(record.semantic_root.as_bytes());
        material_u64(&mut bytes, record.model_generation);
        bytes.extend_from_slice(record.task_identity.as_bytes());
        material_u64(&mut bytes, record.task_epoch);
        for identity in [
            record.task_content.query,
            record.task_content.theory_program,
            record.task_content.result,
        ] {
            bytes.extend_from_slice(identity.as_bytes());
        }
        material_u64(&mut bytes, record.tokens.len() as u64);
        for token in &record.tokens {
            material_u64(&mut bytes, *token);
        }
        material_u64(&mut bytes, record.mapping.len() as u64);
        for row in &record.mapping {
            material_u64(&mut bytes, row.source.len() as u64);
            bytes.extend_from_slice(row.source.as_bytes());
            material_u64(&mut bytes, row.offset);
            material_u64(&mut bytes, row.logical_position);
        }
        for seals in [model_seals, output_seals] {
            material_u64(&mut bytes, seals.len() as u64);
            for (role, index, cells, offset) in seals {
                let digest = self.publication_read(cells.view())?;
                if offset.checked_add(4).is_none_or(|end| end > digest.len()) {
                    self.poisoned = true;
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                material_u64(&mut bytes, role);
                material_u64(&mut bytes, index);
                for word in &digest[offset..offset + 4] {
                    material_u64(&mut bytes, *word);
                }
            }
        }
        Ok(Some(bytes))
    }

    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the original prefill and actual recovered predecessor have independent owners"
    )]
    fn completed_initial_prefill_material(
        &mut self,
        predecessor: SemanticPublishedIdentity,
        recovered_instance: Identity256,
        semantic_root: Identity256,
        prefix_extent: u64,
        model_generation: u64,
        task_identity: Identity256,
        task_content: SemanticTaskContentIdentity,
        owner: Identity256,
    ) -> Result<Option<SemanticCompletedStepWitnessMaterial>, SemanticTransitionError> {
        let live_content = self.original_initial_prefill_content(
            predecessor,
            semantic_root,
            prefix_extent,
            model_generation,
            task_identity,
            task_content,
        )?;
        let (original, content, recovery_referent) =
            if let Some(saved) = &self.checkpoint_initial_prefill {
                if saved.original != predecessor {
                    if saved.original.instance == predecessor.instance
                        || predecessor.word != 0
                        || recovered_instance != saved.original.instance
                        || predecessor.logical_digest != saved.original.logical_digest
                        || predecessor.state_digest != saved.original.state_digest
                        || live_content.is_some()
                    {
                        self.poisoned = true;
                        return Err(SemanticTransitionError::ObservationMismatch);
                    }
                    let referent = saved
                        .recovery_referent
                        .as_ref()
                        .ok_or(SemanticTransitionError::ObservationMismatch)?;
                    (
                        saved.original,
                        saved.content.as_slice(),
                        Some(referent.as_slice()),
                    )
                } else {
                    if live_content.as_deref() != Some(saved.content.as_slice()) {
                        self.poisoned = true;
                        return Err(SemanticTransitionError::ObservationMismatch);
                    }
                    (saved.original, saved.content.as_slice(), None)
                }
            } else {
                let Some(content) = live_content.as_deref() else {
                    return Ok(None);
                };
                (predecessor, content, None)
            };
        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-INITIAL-PREFILL\0");
        material_u64(&mut bytes, 2);
        encode_publication_identity(&mut bytes, original);
        encode_publication_identity(&mut bytes, predecessor);
        if let Some(referent) = recovery_referent {
            bytes.push(2);
            material_u64(
                &mut bytes,
                u64::try_from(referent.len())
                    .map_err(|_| publication_input_error("checkpoint referent exceeds u64"))?,
            );
            bytes.extend_from_slice(referent);
        } else {
            bytes.push(1);
        }
        bytes.extend_from_slice(content);
        Ok(Some(completed_action_child_material(
            owner,
            b"initial-prefill",
            0,
            &bytes,
        )))
    }

    /// Reserve the complete cold export before any execution chooses a bank or
    /// action. Only frozen extents and captured launch metadata are inspected;
    /// no tensor value, publication header, or future result is read.
    #[cfg(feature = "semantic-policy")]
    pub fn prepared_completed_material_capacity(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<SemanticCompletedMaterialCapacity, SemanticTransitionError> {
        let owner = self.checked_prepared_step(step, false)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope");
        if !build.finished || build.capturing || build.active || build.submitted || build.completed
        {
            return Err(publication_input_error(
                "completed material capacity requires finished capture before the first submit",
            ));
        }
        if build.requested_kind(step, &self.publication_issuer)? != SemanticTransitionKind::Proposal
        {
            return Err(publication_input_error(
                "completed material capacity requires an original Proposal",
            ));
        }
        let prepared = owner.prepared.as_ref().expect("checked prepared owner");
        let inputs = owner
            .inputs
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let work = prepared
            .model_work
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let launches = self
            .captured
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .captured_launch_bindings();
        if launches.is_empty()
            || launches
                .iter()
                .any(|launch| launch.artifact_sha256.is_none())
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let task = &self
            .task
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .0;
        let mut capacity = SemanticCompletedMaterialCapacity::default();
        let publication_identity_bytes = 3 * 32 + size_of::<u64>();
        // These are the serialized fields, not the narrower private device ABI.
        let component_receipt_bytes = (2 + 9 + 2 + 4 + 4 + 4 + 4 * 3 + 2) * 8 + 2 * 32;
        let semantic_receipt_bytes = 42 * size_of::<u64>();
        let action_bytes = completed_material_extent(&[
            b"XLOG-COMPLETED-ACTION-WITNESSES\0".len(),
            4 * 8,
            2 * publication_identity_bytes,
            size_of::<DeviceState>(),
            repeated_material_extent(COMPONENT_COUNT, size_of::<SemanticTransitionReceipt>())?,
        ])?;
        capacity.add(action_bytes)?;
        if let Some(saved) = &self.checkpoint_initial_prefill {
            let referent = saved.recovery_referent.as_ref().map_or(0, Vec::len);
            capacity.child(
                b"initial-prefill",
                completed_material_extent(&[
                    b"XLOG-INITIAL-PREFILL\0".len(),
                    8,
                    2 * publication_identity_bytes,
                    1,
                    8,
                    referent,
                    saved.content.len(),
                ])?,
            )?;
        } else if let Some(retained) = &self.retained_initial_prefill {
            let record = &retained.record;
            let mut content = completed_material_extent(&[
                2 * 32,
                2 * 8,
                3 * 32,
                2 * 8,
                repeated_material_extent(record.tokens.len(), 8)?,
                2 * 8,
                repeated_material_extent(
                    initial_prefill_seal_sources(&retained.model)?.len(),
                    6 * 8,
                )?,
                repeated_material_extent(
                    initial_prefill_seal_sources(&retained.output)?.len(),
                    6 * 8,
                )?,
            ])?;
            for row in &record.mapping {
                content = completed_material_extent(&[content, 3 * 8, row.source.len()])?;
            }
            capacity.child(
                b"initial-prefill",
                completed_material_extent(&[
                    b"XLOG-INITIAL-PREFILL\0".len(),
                    8,
                    2 * publication_identity_bytes,
                    1,
                    content,
                ])?,
            )?;
        }
        capacity.add(
            self.graph
                .transition_root_material_capacity()
                .map_err(SemanticTransitionError::Semantic)?,
        )?;
        capacity.add(
            self.graph
                .admission()
                .ok_or(SemanticTransitionError::ObservationMismatch)?
                .schema_bytes()
                .len(),
        )?;
        capacity.add(SemanticActionCatalogue::current().canonical_bytes().len())?;
        capacity.add(repeated_material_extent(self.codebooks.words.len(), 8)?)?;
        capacity.add(completed_material_extent(&[
            b"xlog.semantic-action-roster.v1\0".len(),
            32 + 8,
            repeated_material_extent(self.codebooks.components.len(), 7 * 8)?,
        ])?)?;
        capacity.add(size_of::<SemanticActionBatchReceipt>())?;
        capacity.add(task.completed_result_material().bytes.len())?;
        for _ in 0..2 {
            capacity.child(b"action-rng", 4 * 8)?;
            capacity.child(b"logical-state", publication_identity_bytes)?;
            capacity.child(b"lane-admission", semantic_receipt_bytes)?;
            for _ in 0..2 {
                capacity.child(b"hard-decode-receipt", semantic_receipt_bytes)?;
            }
        }
        capacity.child(b"slot-zero-admission", semantic_receipt_bytes)?;
        for component in &self.codebooks.components {
            let mask = completed_material_extent(&[8, component.cardinality as usize])?;
            capacity.child(b"final-mask", mask)?;
            capacity.child(b"active-set", mask)?;
            capacity.child(b"component-receipt", component_receipt_bytes)?;
            capacity.child(b"pwl-cell", size_of::<SemanticPolicyPwlCell>())?;
            capacity.child(b"vjp", size_of::<SemanticPolicySelectedScoreVjp>())?;
        }
        // Every edit slot may emit both a delta and its refusal/acceptance
        // evidence. NULL, winner selection, and digest aliases cannot shrink
        // the reservation before execution.
        let editable_program = task.spec().program.editable_program().is_some();
        let (delta_kind, evidence_kind, delta_bytes, evidence_prefix) = if editable_program {
            (
                b"theory-rule-delta".as_slice(),
                b"theory-rule-delta-evidence".as_slice(),
                b"XLOG-DECODED-RULE-INSERTION\0".len() + 8 + 2 * 32 + (18 + 10) * 4,
                2 * 32 + 3 * 8,
            )
        } else {
            (
                b"theory-delta".as_slice(),
                b"theory-delta-evidence".as_slice(),
                b"XLOG-DECODED-SUPPORT-INSERTION\0".len() + 8 + 3 * 32 + (18 + 1 + 10) * 4,
                32 + 3 * 8 + (1 + 10) * 4,
            )
        };
        for _ in 0..4 {
            capacity.child(delta_kind, delta_bytes)?;
            capacity.child(
                evidence_kind,
                completed_material_extent(&[
                    evidence_prefix,
                    2 * semantic_receipt_bytes,
                    18 * component_receipt_bytes,
                ])?,
            )?;
        }
        let mut ground = completed_material_extent(&[
            b"XLOG-COMPLETED-TASK-GROUND\0".len(),
            17 * 8,
            10 * 32,
            publication_identity_bytes,
            3 * size_of::<SemanticTaskFacts>(),
        ])?;
        for level in task.priority_levels() {
            ground = completed_material_extent(&[
                ground,
                8,
                repeated_material_extent(level.goals.len(), 3 * 8)?,
            ])?;
        }
        capacity.child(b"task-ground", ground)?;
        capacity.child(
            b"task-scoring-law",
            task.spec()
                .scoring
                .completed_law_bytes(task.identity(), editable_program)?
                .len(),
        )?;
        capacity.child(
            b"edit-solution",
            b"XLOG-COMPLETED-EDIT-SOLUTION\0".len() + 8 + 64 + 32 + 6 * 8 + 3 * 64 + 68 * 5 * 64,
        )?;
        capacity.attempt_receipt_bytes = capacity.child(b"attempt-receipt", 4 * 8 + 10 * 32)?;
        if let Some(roster) = &inputs.storage.physical_parameter_roster {
            let mut names = 0;
            for name in roster {
                names = completed_material_extent(&[names, name.len()])?;
            }
            let mut original_records = 0;
            for bank in 0..2 {
                let model = inputs.views[bank]
                    .get(&(44, 0))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?
                    .len();
                let profile = inputs.storage.bank_templates[bank]
                    .iter()
                    .find(|range| range.role == 43 && range.index == 0)
                    .and_then(|range| usize::try_from(range.length_bytes).ok())
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                original_records =
                    original_records.max(completed_material_extent(&[model, profile])?);
            }
            capacity.child(
                b"estimator-bound",
                completed_material_extent(&[
                    b"XLOG-ESTIMATOR-BOUND\0".len(),
                    4 * 8,
                    publication_identity_bytes,
                    8,
                    3 * 32,
                    2 * 64,
                    2 * 32,
                    6 * 8,
                    3 * 8,
                    original_records,
                    repeated_material_extent(roster.len(), 7 * 8)?,
                    names,
                ])?,
            )?;
        }
        let mut graph = b"XLOG-CAPTURED-CUDA-LAUNCH-BINDINGS\0".len() + 2 * 8;
        for launch in launches {
            graph = completed_material_extent(&[
                graph,
                13 * 8 + 32,
                launch.module_name.len(),
                launch.artifact_name.len(),
                launch.function_name.len(),
            ])?;
        }
        let work_bytes = completed_material_extent(&[
            b"XLOG-COMPLETED-STEP-WITNESSES\0".len(),
            15 * 8,
            2 * publication_identity_bytes,
            2 * 32,
            repeated_material_extent(work.recording.events().len(), (4 + 8 + 3) * 8)?,
        ])?;
        let numerical = completed_material_extent(&[
            b"XLOG-COMPLETED-NUMERICAL-REALIZATION\0".len(),
            4 * 8,
            graph,
            work_bytes,
            action_bytes,
        ])?;
        let mut logits = 0;
        for branch in &prepared.branches {
            let policy = branch
                .policy
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let field_count = repeated_material_extent(policy.layout.fields.len(), 4)?;
            let mut scores = 0;
            for field in &policy.layout.fields {
                scores = completed_material_extent(&[scores, field.cardinality])?;
            }
            logits = logits.max(completed_material_extent(&[
                b"XLOG-COMPLETED-EDIT-LOGITS\0".len(),
                2 * 8,
                repeated_material_extent(field_count, 5 * 8)?,
                repeated_material_extent(scores, 4 * 4)?,
            ])?);
        }
        let random = b"XLOG-COMPLETED-RANDOM-STATE\0".len() + 11 * 8 + COMPONENT_COUNT * 12 * 8;
        capacity.carrier_bytes = [numerical, logits, random];
        for bytes in capacity.carrier_bytes {
            capacity.add(bytes)?;
        }
        for plan in inputs
            .plans
            .iter()
            .filter(|plan| matches!(plan.role, 15..=17))
        {
            let mut bytes = 0;
            for bank in &plan.banks {
                bytes = bytes.max(
                    bank.span
                        .end
                        .checked_sub(bank.span.start)
                        .ok_or(SemanticTransitionError::ObservationMismatch)?,
                );
            }
            capacity.add(bytes)?;
        }
        let mut evidence = REPLAY_EVIDENCE_MAGIC.len() + 2 * 4 + 32 + publication_identity_bytes;
        for role in REPLAY_EVIDENCE_ROLES {
            let mut bytes = 0;
            for bank in &inputs.storage.bank_templates {
                let range = bank
                    .iter()
                    .find(|range| range.role == role && range.index == 0)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let slot = usize::try_from(range.storage_slot)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
                let offset = usize::try_from(range.offset_bytes)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
                let allocation = inputs
                    .storage
                    .allocations
                    .get(slot)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                bytes = bytes.max(
                    allocation
                        .len()
                        .checked_sub(offset)
                        .ok_or(SemanticTransitionError::ObservationMismatch)?,
                );
            }
            evidence = completed_material_extent(&[
                evidence,
                2 * 4 + size_of::<PublicationRange>() + 8,
                bytes,
            ])?;
        }
        capacity.publication_evidence_bytes = evidence;
        let custody = prepared
            .replay_custody
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let (parent, provenance) = custody.material_capacity(
            &inputs.storage,
            self.graph
                .transition_root_material_capacity()
                .map_err(SemanticTransitionError::Semantic)?,
        )?;
        capacity.add(parent)?;
        capacity.add(provenance)?;
        capacity.child(b"pre-action-checkpoint", Self::CHECKPOINT_REFERENT_BYTES)?;
        Ok(capacity)
    }

    /// Project one completed Proposal into typed action-law values and canonical
    /// byte-backed child materials. Private device structs never cross this API.
    #[cfg(feature = "semantic-policy")]
    pub fn prepared_completed_action_projection(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<SemanticCompletedActionProjectionMaterial, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        if self.completed_prepared_transition_kind(step)? != SemanticTransitionKind::Proposal {
            return Err(publication_input_error(
                "completed action projection requires an original Proposal",
            ));
        }
        let successor = binding
            .1
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let result_view = self
            .checked_prepared_step(step, false)?
            .prepared
            .as_ref()
            .expect("checked prepared owner")
            .result
            .view();
        let result = self.publication_read(result_view)?[0];
        let parent_header_view = self
            .checked_prepared_step(step, false)?
            .inputs
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .header
            .view();
        let parent_header = self.publication_read(parent_header_view)?[0];
        if (SemanticPublishedIdentity {
            instance: parent_header.instance,
            word: parent_header.publication_word,
            logical_digest: parent_header.logical_digest,
            state_digest: parent_header.state_digest,
        }) != binding.0
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let parent_semantic_digest = parent_header.semantic_digest;
        let world_root = self.prepared_parent_root_material(step, &parent_header)?;
        let world_root = SemanticCompletedStepWitnessMaterial {
            identity: Identity256::from_bytes(world_root.digest),
            bytes: world_root
                .encode()
                .map_err(SemanticTransitionError::Semantic)?,
        };
        let tape_index = self.completed_prepared_policy_tape(step)?;
        let bank = self.policy_tapes[tape_index]
            .prepared_bank
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let (
            state_view,
            receipt_view,
            final_mask_view,
            active_set_view,
            pwl_cell_view,
            selected_score_vjp_view,
        ) = {
            let prepared = self
                .checked_prepared_step(step, false)?
                .prepared
                .as_ref()
                .expect("checked prepared owner");
            let branch = &prepared.branches[bank];
            let tape = &self.policy_tapes[tape_index];
            let policy = &tape.policy;
            (
                branch.state.view(),
                tape.receipts.view(),
                policy.final_masks.view(),
                policy.active_sets.view(),
                policy.pwl_cells.view(),
                policy.selected_score_vjps.view(),
            )
        };
        let state = self.publication_read(state_view)?[0];
        let receipts = self.publication_read(receipt_view)?;
        let final_masks = self.publication_read(final_mask_view)?;
        let active_sets = self.publication_read(active_set_view)?;
        let pwl_cells = self.publication_read(pwl_cell_view)?;
        let selected_score_vjps = self.publication_read(selected_score_vjp_view)?;
        let schema_generation = {
            let admission = self
                .graph
                .admission()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            SemanticCompletedStepWitnessMaterial {
                identity: admission.schema_generation(),
                bytes: admission.schema_bytes().to_vec(),
            }
        };
        let catalogue = self.codebooks.binding;
        let batch_root = state.action_batch_root;
        let (
            task_identity,
            task_content,
            expected_truth,
            scoring,
            editable_program,
            objective_law,
            goal,
            priority_levels,
            task_result,
        ) = {
            let task = &self
                .task
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?
                .0;
            (
                task.identity(),
                task.content_identity(),
                task.expected_truth(),
                task.spec().scoring,
                task.spec().program.editable_program().is_some(),
                task.objective_law,
                task.goal_witness()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?,
                task.priority_levels().to_vec(),
                task.completed_result_material(),
            )
        };
        // A hard-constraint refusal follows completed queries. Scope and
        // program-resource refusals have no query result; their actual edit
        // costs and refusal penalties remain checked by the scoring law.
        let executed_slots = [
            true,
            matches!(state.task_evaluation.lane_refusal[0], 0 | 2),
            matches!(state.task_evaluation.lane_refusal[1], 0 | 2),
        ];
        let expected_query_count =
            executed_slots.iter().filter(|executed| **executed).count() as u64 * 3;
        let invalid_task_facts =
            state
                .task_evaluation
                .facts
                .iter()
                .zip(executed_slots)
                .any(|(facts, executed)| {
                    facts.correct.iter().any(|&value| value > 1)
                        || facts.g > 3
                        || facts.p > 1
                        || facts.eligible > 1
                        || if executed {
                            facts.truth.iter().any(|&value| value > 3)
                                || facts
                                    .truth
                                    .iter()
                                    .zip(expected_truth)
                                    .zip(facts.correct)
                                    .any(|((&truth, expected), correct)| {
                                        correct != u64::from(truth == expected as u64)
                                    })
                                || facts.g != facts.correct.iter().sum::<u64>()
                                || facts.p != u64::from(facts.correct == [1; 3])
                        } else {
                            facts.truth != [0; 3]
                                || facts.correct != [0; 3]
                                || facts.g != 0
                                || facts.p != 0
                                || facts.eligible != 0
                        }
                });
        let invalid_task_scoring = !validate_completed_task_scoring(
            scoring,
            editable_program,
            &priority_levels,
            &state.task_evaluation.facts,
            &state.work,
            state.task_evaluation.lane_refusal,
            state.task_evaluation.query_count,
            state.task_evaluation.winner,
            state.task_evaluation.return_value,
        );
        if result.refusal != 0
            || result.advanced != 1
            || state.status != 0
            || state.blocks != COMPONENT_COUNT as u64
            || receipts.len() != COMPONENT_COUNT
            || final_masks.len() != self.codebooks.input_cells
            || active_sets.len() != self.codebooks.input_cells
            || pwl_cells.len() != COMPONENT_COUNT
            || selected_score_vjps.len() != COMPONENT_COUNT
            || state.proposal.checked_add(1) != Some(state.next_proposal)
            || state.next_proposal != result.header.proposal
            || state.stream_serial != result.header.stream_serial
            || state.family_id as u64 != result.header.family_id
            || state.model_generation as u64 != result.header.model_generation
            || state.proposal > u32::MAX as u64
            || state.stream_serial >= 1 << 56
            || state.family_id > u8::MAX as u32
            || state.catalogue_generation > u32::MAX as u64
            || state.catalogue_generation != catalogue.generation
            || state.catalogue_digest != catalogue.digest
            || state.binding_digest != self.codebooks.binding.digest
            || self.codebooks.words[10..14]
                != identity_words(*schema_generation.identity.as_bytes())
            || state.task_evaluation.winner > 2
            || state.task_evaluation.query_count != expected_query_count
            || invalid_task_facts
            || invalid_task_scoring
            || state.task_evaluation.facts[state.task_evaluation.winner as usize].eligible != 1
            || state
                .task_evaluation
                .lane_refusal
                .iter()
                .any(|&code| code > 4)
            || (state.task_evaluation.winner != 0
                && state.task_evaluation.lane_refusal[state.task_evaluation.winner as usize - 1]
                    != 0)
            || state
                .task_evaluation
                .facts
                .iter()
                .any(|facts| facts.eligible > 1)
            || final_masks
                .iter()
                .chain(&active_sets)
                .any(|&value| value > 1)
            || state.actor_eligible > 1
            || state.action_batch.abi != 1
            || publication_action_batch_root(&state.action_batch) != batch_root
            || result.attempt.action_receipts_digest != batch_root
            || state.action_batch.proposal != state.proposal
            || state.action_batch.stream_serial != state.stream_serial
            || state.action_batch.family_id != u64::from(state.family_id)
            || state.action_batch.action_law_generation != state.catalogue_generation
            || state.action_batch.model_generation != u64::from(state.model_generation)
            || state.action_batch.actor_eligible != state.actor_eligible
            || state.action_batch.component_count != COMPONENT_COUNT as u64
            || state.action_batch.candidate_count != 3
            || state.action_batch.winner != state.task_evaluation.winner
            || state.action_batch.total_return_bits != state.task_evaluation.return_value as u64
            || state.action_batch.base_word != binding.0.word
            || state.action_batch.next_word != successor.word
            || state.action_batch.rng_base != state.proposal * COMPONENT_COUNT as u64
            || state.action_batch.rng_span != COMPONENT_COUNT as u64
            || state.action_batch.rng_successor != state.next_proposal * COMPONENT_COUNT as u64
            || state.action_batch.catalogue_digest != state.catalogue_digest
            || state.action_batch.semantic_receipts_digest
                != publication_semantic_receipts_digest(&state.semantic_receipts)
            || state.action_batch.base_logical_digest != binding.0.logical_digest
            || state.action_batch.execution_work != state.execution_work
            || [0usize, 3, 6]
                .into_iter()
                .enumerate()
                .any(|(candidate, receipt)| {
                    identity_words(*state.action_batch.candidate_roots[candidate].as_bytes())
                        != state.semantic_receipts[receipt][16..20]
                })
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }

        let owner = self.prepared_completed_action_witnesses(step, consumer_streams)?;
        let owner_identity = owner.identity;
        let initial_prefill = self.completed_initial_prefill_material(
            binding.0,
            parent_header.recovered_instance,
            parent_semantic_digest,
            parent_header.prefix_extent,
            state.model_generation as u64,
            task_identity,
            task_content,
            owner_identity,
        )?;
        let component_receipts_digest = publication_action_receipts_digest_bytes(
            &publication_abi_bytes(&self.codebooks.words),
            &receipts,
        )?;
        if state.action_batch.component_receipts_digest != component_receipts_digest {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let batch_receipt = SemanticCompletedStepWitnessMaterial {
            identity: batch_root,
            bytes: publication_abi_bytes(&[state.action_batch]),
        };

        let slot_zero_admission = completed_receipt_material(
            owner_identity,
            b"slot-zero-admission",
            0,
            &state.semantic_receipts[0],
        );
        let lane_admissions: [SemanticCompletedStepWitnessMaterial; 2] =
            std::array::from_fn(|lane| {
                completed_receipt_material(
                    owner_identity,
                    b"lane-admission",
                    lane as u64,
                    &state.semantic_receipts[3 + lane * 3],
                )
            });
        let hard_decode_receipts: [[SemanticCompletedStepWitnessMaterial; 2]; 2] =
            std::array::from_fn(|lane| {
                std::array::from_fn(|slot| {
                    completed_receipt_material(
                        owner_identity,
                        b"hard-decode-receipt",
                        (lane * 2 + slot) as u64,
                        &state.semantic_receipts[1 + lane * 3 + slot],
                    )
                })
            });

        let mut components = Vec::new();
        components
            .try_reserve_exact(COMPONENT_COUNT)
            .map_err(|error| runtime_error("completed action component reservation", error))?;
        for (ordinal, (&component, &receipt)) in
            self.codebooks.components.iter().zip(&receipts).enumerate()
        {
            let begin = component.offset as usize;
            let end = begin
                .checked_add(component.cardinality as usize)
                .filter(|&end| end <= final_masks.len())
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let final_mask = &final_masks[begin..end];
            let active_set = &active_sets[begin..end];
            let pwl_cell = pwl_cells[ordinal];
            let selected_score_vjp = selected_score_vjps[ordinal];
            let block = (COMPONENT_COUNT as u64)
                .checked_mul(state.proposal)
                .and_then(|block| block.checked_add(ordinal as u64))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let packed = (state.stream_serial << 8) | state.family_id as u64;
            let expected_counter = [
                block as u32,
                (block >> 32) as u32,
                packed as u32,
                (packed >> 32) as u32,
            ];
            if receipt.ordinal as usize != ordinal
                || receipt.ordinal != component.ordinal
                || receipt.lane != component.lane
                || receipt.slot != component.slot
                || receipt.field != component.field
                || receipt.kind != component.kind
                || receipt.proposal != state.proposal
                || receipt.catalogue_generation != catalogue.generation
                || receipt.catalogue_digest != catalogue.digest
                || receipt.admission_binding != state.binding_digest
                || receipt.choice >= component.cardinality
                || receipt.legal_count == 0
                || receipt.active_count == 0
                || receipt.selected_rank >= receipt.legal_count
                || final_mask.iter().map(|&value| value as u32).sum::<u32>() != receipt.legal_count
                || active_set.iter().map(|&value| value as u32).sum::<u32>() != receipt.active_count
                || final_mask[receipt.choice as usize] != 1
                || active_set[receipt.choice as usize] != 1
                || receipt.cdf_start >= receipt.cdf_end
                || receipt.cdf_end > 1 << 63
                || receipt.mass != receipt.cdf_end - receipt.cdf_start
                || receipt.p == [0; 3]
                || receipt.q == [0; 3]
                || receipt.factor_denominator == [0; 3]
                || receipt.key != [state.catalogue_generation as u32, state.model_generation]
                || receipt.counter != expected_counter
                || pwl_cell.abi != 1
                || pwl_cell.ordinal != ordinal as u64
                || pwl_cell.cardinality != u64::from(component.cardinality)
                || pwl_cell.legal_count != u64::from(receipt.legal_count)
                || pwl_cell.active_count != u64::from(receipt.active_count)
                || pwl_cell.selected_rank != u64::from(receipt.selected_rank)
                || pwl_cell.singleton != u64::from(receipt.legal_count == 1)
                || pwl_cell.maximum_bits >> 32 != 0
                || !f32::from_bits(pwl_cell.maximum_bits as u32).is_finite()
                || pwl_cell.selected_probability != receipt.p
                || pwl_cell.probability_denominator != receipt.q
                || selected_score_vjp.abi != 1
                || selected_score_vjp.ordinal != ordinal as u64
                || selected_score_vjp.choice != u64::from(receipt.choice)
                || selected_score_vjp.active_count != u64::from(receipt.active_count)
                || selected_score_vjp.selected_active != 1
                || selected_score_vjp.singleton != u64::from(receipt.legal_count == 1)
                || selected_score_vjp.probability_numerator != receipt.p
                || selected_score_vjp.probability_denominator != receipt.q
            {
                self.poisoned = true;
                return Err(SemanticTransitionError::ObservationMismatch);
            }

            let mut final_mask_bytes = Vec::new();
            material_u64(&mut final_mask_bytes, component.cardinality as u64);
            final_mask_bytes.extend_from_slice(final_mask);
            let final_mask_material = completed_action_child_material(
                owner_identity,
                b"final-mask",
                ordinal as u64,
                &final_mask_bytes,
            );
            let mut active_set_bytes = Vec::new();
            material_u64(&mut active_set_bytes, component.cardinality as u64);
            active_set_bytes.extend_from_slice(active_set);
            let active_set_material = completed_action_child_material(
                owner_identity,
                b"active-set",
                ordinal as u64,
                &active_set_bytes,
            );
            let mut receipt_bytes = Vec::new();
            encode_completed_component_receipt(&mut receipt_bytes, receipt);
            let component_receipt = completed_action_child_material(
                owner_identity,
                b"component-receipt",
                ordinal as u64,
                &receipt_bytes,
            );
            let pwl_cell = completed_action_child_material(
                owner_identity,
                b"pwl-cell",
                ordinal as u64,
                &publication_abi_bytes(&[pwl_cell]),
            );

            let null = if component.is_text() {
                receipt.choice == TEXT_NULL as u32
            } else {
                component.field != 0
                    && receipt.choice == 0
                    && receipt.legal_count == 1
                    && receipt.active_count == 1
            };
            let vjp = completed_action_child_material(
                owner_identity,
                b"vjp",
                ordinal as u64,
                &publication_abi_bytes(&[selected_score_vjp]),
            );
            let hard_decode_receipt = (!component.is_text()).then(|| {
                hard_decode_receipts[component.lane as usize - 1][component.slot as usize].clone()
            });
            components.push(SemanticCompletedActionComponentMaterial {
                ordinal: receipt.ordinal,
                null,
                choice: receipt.choice,
                legal_count: receipt.legal_count,
                active_count: receipt.active_count,
                probability_numerator: receipt.p,
                probability_denominator: receipt.q,
                importance_denominator: receipt.factor_denominator,
                cumulative_mass_below: receipt.cumulative_mass_below,
                cdf_start: receipt.cdf_start,
                cdf_end: receipt.cdf_end,
                mass: receipt.mass,
                selected_rank: receipt.selected_rank,
                draw: receipt.draw,
                key: receipt.key,
                counter: receipt.counter,
                final_mask: final_mask_material,
                pwl_cell,
                active_set: active_set_material,
                vjp,
                component_receipt,
                hard_decode_receipt,
            });
        }

        let lanes = std::array::from_fn(|lane| {
            let text_actions = (0..32)
                .filter_map(|slot| {
                    let receipt = receipts[lane * 68 + slot];
                    (receipt.choice != TEXT_NULL as u32).then_some((slot as u32, receipt.choice))
                })
                .collect();
            let mut edit_actions = [[0; 18]; 2];
            for slot in 0..2 {
                for field in 0..18 {
                    edit_actions[slot][field] = receipts[lane * 68 + 32 + slot * 18 + field].choice;
                }
            }
            SemanticCompletedActionLaneMaterial {
                text_actions,
                edit_actions,
                admitted: state.task_evaluation.lane_refusal[lane] == 0,
                refusal_reason: match state.task_evaluation.lane_refusal[lane] {
                    0 => None,
                    1 => Some(SemanticTaskRefusal::Scope.canonical_kind()),
                    2 => Some(SemanticTaskRefusal::HardConstraint.canonical_kind()),
                    3 => Some(SemanticTaskRefusal::FactCapacity.canonical_kind()),
                    4 => Some(SemanticTaskRefusal::FuelExhausted.canonical_kind()),
                    _ => unreachable!("validated lane refusal code"),
                },
                admission: lane_admissions[lane].clone(),
                hard_decode_receipts: hard_decode_receipts[lane].clone(),
            }
        });

        let admission = self
            .graph
            .admission()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let task_program = self
            .task
            .as_ref()
            .and_then(|(task, _)| task.spec().program.editable_program())
            .cloned();
        if let Some(program) = task_program.as_ref() {
            let edits = std::array::from_fn(|lane| lanes[lane].edit_actions);
            if let Err(error) = validate_program_query_receipts(
                program,
                task_identity,
                &self.codebooks,
                &state,
                &edits,
            ) {
                self.poisoned = true;
                return Err(error);
            }
        }
        let mut theory_deltas = Vec::new();
        for (lane, lane_material) in lanes.iter().enumerate() {
            for slot in 0..2 {
                let begin = lane * 68 + 32 + slot * 18;
                let projected = completed_theory_delta_for_slot(
                    &self.codebooks,
                    admission,
                    task_program.as_ref(),
                    task_identity,
                    owner_identity,
                    parent_semantic_digest,
                    lane,
                    slot,
                    &lane_material.edit_actions[slot],
                    (slot == 1).then_some(&lane_material.edit_actions[0]),
                    &state.semantic_receipts[1 + lane * 3 + slot],
                    &state.semantic_receipts[3 + lane * 3],
                    &receipts[begin..begin + 18],
                    state.task_evaluation.lane_refusal[lane],
                );
                match projected {
                    Ok(Some(delta)) => theory_deltas.push(delta),
                    Ok(None) => {}
                    Err(error) => {
                        self.poisoned = true;
                        return Err(error);
                    }
                }
            }
        }

        let base_truth = completed_task_truths(state.task_evaluation.facts[0])?;
        let lane_outcomes =
            std::array::from_fn(|lane| match state.task_evaluation.lane_refusal[lane] {
                0 => SemanticCompletedLaneOutcomeMaterial::Executed(
                    completed_task_truths(state.task_evaluation.facts[lane + 1])
                        .expect("validated executed task truth"),
                ),
                1 => SemanticCompletedLaneOutcomeMaterial::Refused(SemanticTaskRefusal::Scope),
                2 => SemanticCompletedLaneOutcomeMaterial::Refused(
                    SemanticTaskRefusal::HardConstraint,
                ),
                3 => {
                    SemanticCompletedLaneOutcomeMaterial::Refused(SemanticTaskRefusal::FactCapacity)
                }
                4 => SemanticCompletedLaneOutcomeMaterial::Refused(
                    SemanticTaskRefusal::FuelExhausted,
                ),
                _ => unreachable!("validated lane refusal code"),
            });
        let mut ground_bytes = Vec::new();
        ground_bytes.extend_from_slice(b"XLOG-COMPLETED-TASK-GROUND\0");
        material_u64(&mut ground_bytes, 3);
        let structural_cost = objective_law.structural_cost;
        ground_bytes.extend_from_slice(structural_cost.unit.as_bytes());
        material_u64(&mut ground_bytes, structural_cost.cap);
        ground_bytes.extend_from_slice(task_identity.as_bytes());
        for identity in [
            task_content.query,
            task_content.theory_program,
            task_content.result,
        ] {
            ground_bytes.extend_from_slice(identity.as_bytes());
        }
        for identity in [
            goal.semantic_root,
            goal.authority_root,
            goal.mandatory_links_root,
            goal.constraints_root,
        ] {
            ground_bytes.extend_from_slice(identity.as_bytes());
        }
        material_u64(&mut ground_bytes, goal.mandatory_link_count);
        material_u64(&mut ground_bytes, goal.constraint_count);
        material_u64(&mut ground_bytes, priority_levels.len() as u64);
        for level in &priority_levels {
            material_u64(&mut ground_bytes, level.goals.len() as u64);
            for goal in &level.goals {
                for value in [
                    u64::from(goal.query),
                    u64::from(goal.target_truth),
                    u64::from(goal.weight),
                ] {
                    material_u64(&mut ground_bytes, value);
                }
            }
        }
        encode_publication_identity(&mut ground_bytes, binding.0);
        for truth in expected_truth {
            material_u64(&mut ground_bytes, truth as u64);
        }
        for facts in state.task_evaluation.facts {
            encode_completed_task_facts(&mut ground_bytes, facts);
        }
        material_u64(&mut ground_bytes, state.task_evaluation.query_count);
        for refusal in state.task_evaluation.lane_refusal {
            material_u64(&mut ground_bytes, refusal);
        }
        for work in state.work {
            for value in [
                work.edit_commands,
                work.added_supports,
                work.defined_truth_changes,
            ] {
                material_u64(&mut ground_bytes, value);
            }
        }
        ground_bytes.extend_from_slice(batch_root.as_bytes());
        let task_ground = SemanticCompletedTaskGroundMaterial {
            witness: completed_action_child_material(
                owner_identity,
                b"task-ground",
                0,
                &ground_bytes,
            ),
            scoring_law: completed_action_child_material(
                owner_identity,
                b"task-scoring-law",
                0,
                &scoring.completed_law_bytes(task_identity, editable_program)?,
            ),
            scoring,
            return_bound: objective_law.return_bound,
            structural_cost,
            task_identity,
            content: task_content,
            goal,
            priority_levels,
            base: binding.0,
            expected_truth,
            facts: state.task_evaluation.facts,
            base_truth,
            lane_outcomes,
        };

        let base_solves = state.task_evaluation.facts[0].eligible == 1
            && state.task_evaluation.facts[0].p == 1
            && state.task_evaluation.facts[0].correct == [1; 3];
        let decisive_lane = (0..2).find(|&lane| {
            let facts = state.task_evaluation.facts[lane + 1];
            state.task_evaluation.lane_refusal[lane] == 0
                && state.semantic_receipts[3 + lane * 3][0] == 0
                && state.work[lane].added_supports > 0
                && !base_solves
                && facts.eligible == 1
                && facts.p == 1
                && facts.correct == [1; 3]
        });
        let edit_solution = decisive_lane.map(|lane| {
            let component_begin = lane * 68 + 32;
            let component_end = lane * 68 + 68;
            let mut solution_bytes = Vec::new();
            solution_bytes.extend_from_slice(b"XLOG-COMPLETED-EDIT-SOLUTION\0");
            material_u64(&mut solution_bytes, 1);
            bind_completed_material(&mut solution_bytes, &task_ground.witness);
            solution_bytes.extend_from_slice(batch_root.as_bytes());
            material_u64(&mut solution_bytes, (lane + 1) as u64);
            material_u64(&mut solution_bytes, component_begin as u64);
            material_u64(&mut solution_bytes, component_end as u64);
            for value in [
                state.work[lane].edit_commands,
                state.work[lane].added_supports,
                state.work[lane].defined_truth_changes,
            ] {
                material_u64(&mut solution_bytes, value);
            }
            bind_completed_material(&mut solution_bytes, &lanes[lane].admission);
            for receipt in &lanes[lane].hard_decode_receipts {
                bind_completed_material(&mut solution_bytes, receipt);
            }
            for component in &components[lane * 68..(lane + 1) * 68] {
                for material in [
                    &component.component_receipt,
                    &component.final_mask,
                    &component.pwl_cell,
                    &component.active_set,
                    &component.vjp,
                ] {
                    bind_completed_material(&mut solution_bytes, material);
                }
            }
            SemanticCompletedEditSolutionMaterial {
                witness: completed_action_child_material(
                    owner_identity,
                    b"edit-solution",
                    lane as u64,
                    &solution_bytes,
                ),
                lane: (lane + 1) as u64,
                component_begin: component_begin as u64,
                component_end: component_end as u64,
                structural_delta: state.work[lane],
                resulting_state_receipt: lanes[lane].admission.clone(),
            }
        });

        let mut attempt_bytes = Vec::new();
        material_u64(&mut attempt_bytes, result.attempt.abi);
        material_u64(&mut attempt_bytes, result.attempt.transition_kind);
        attempt_bytes.extend_from_slice(result.attempt.instance.as_bytes());
        material_u64(&mut attempt_bytes, result.attempt.base_word);
        material_u64(&mut attempt_bytes, result.attempt.next_word);
        for digest in [
            result.attempt.logical_digest,
            result.attempt.action_receipts_digest,
            result.attempt.semantic_receipts_digest,
            result.attempt.coverage_digest,
            result.attempt.replay_head_digest,
            result.attempt.intent_head_digest,
            result.attempt.acknowledgement_head_digest,
            result.attempt.previous_attempt_digest,
            result.attempt.receipt_digest,
        ] {
            attempt_bytes.extend_from_slice(digest.as_bytes());
        }
        let mut attempt_receipt =
            completed_action_child_material(owner_identity, b"attempt-receipt", 0, &attempt_bytes);
        attempt_receipt.identity = result.attempt.receipt_digest;
        let estimator_bound = if state.actor_eligible == 1 {
            self.prepared_completed_estimator_bound(
                step,
                bank,
                &parent_header,
                &task_ground.scoring_law,
                &batch_receipt,
                owner_identity,
            )?
        } else {
            None
        };
        let projection = SemanticCompletedActionProjectionMaterial {
            owner,
            initial_prefill,
            pre_action_checkpoint: self
                .checked_prepared_step(step, false)?
                .prepared
                .as_ref()
                .expect("checked prepared owner")
                .replay_custody
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?
                .checkpoint_child
                .clone(),
            world_root: Some(world_root),
            schema_generation,
            action_law: SemanticActionCatalogue::current().completed_material(),
            edit_codebook: self.codebooks.completed_material(),
            roster: self.codebooks.completed_roster_material(),
            estimator_bound,
            predecessor_semantic_root_digest: parent_semantic_digest,
            predecessor: binding.0,
            successor,
            proposal: state.proposal,
            stream_serial: state.stream_serial,
            family_id: state.family_id as u64,
            action_law_generation: state.catalogue_generation,
            model_generation: state.model_generation as u64,
            winner: state.task_evaluation.winner,
            actor_eligible: state.actor_eligible == 1,
            total_return_bits: state.task_evaluation.return_value as u64,
            batch_root,
            batch_receipt,
            result: task_result,
            action_rng_base: completed_rng_material(
                owner_identity,
                0,
                state.model_generation as u64,
                state.stream_serial,
                state.family_id as u64,
                state.proposal,
            ),
            action_rng_successor: completed_rng_material(
                owner_identity,
                1,
                state.model_generation as u64,
                state.stream_serial,
                state.family_id as u64,
                state.next_proposal,
            ),
            base_logical_state: completed_logical_state_material(owner_identity, 0, binding.0),
            successor_logical_state: completed_logical_state_material(owner_identity, 1, successor),
            slot_zero_admission,
            lanes,
            theory_deltas,
            components,
            task_ground,
            edit_solution,
            attempt_receipt,
        };
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(projection)
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_completed_estimator_bound(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        parent: &PublicationHeader,
        scoring_law: &SemanticCompletedStepWitnessMaterial,
        batch_receipt: &SemanticCompletedStepWitnessMaterial,
        owner_identity: Identity256,
    ) -> Result<Option<SemanticCompletedStepWitnessMaterial>, SemanticTransitionError> {
        let tape_index = self.completed_prepared_policy_tape(step)?;
        let (original, storage, profile) = {
            let owner = self.checked_prepared_step(step, false)?;
            let inputs = owner.inputs.as_ref().expect("checked original inputs");
            let policy = &self.policy_tapes[tape_index].policy;
            let Some(profile) =
                inputs.views[bank].get(&(SemanticStateRole::RuntimeContract as u64, 0))
            else {
                return Err(SemanticTransitionError::ObservationMismatch);
            };
            (
                Arc::clone(&policy.text_binding),
                Arc::clone(&inputs.storage),
                profile.clone(),
            )
        };
        let Some(snapshot) = original.numerical_block_snapshot.as_ref() else {
            return Ok(None);
        };
        let contract = original
            .model_contract
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let contract = self.publication_read(contract.clone())?;
        let layout = storage.contract_value.model_contract_layout;
        let roster = model_physical_parameter_roster(&contract, layout)?
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let domain = self
            .task_training_domain()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .identity();
        let bounds = self.publication_read(snapshot.view())?;
        if original.physical_blocks != roster.len() as u64
            || storage.physical_parameter_roster.as_ref() != Some(&roster)
            || roster.len().checked_mul(6) != Some(bounds.len())
            || u64::from_le_bytes(
                contract[layout.generation_offset as usize..layout.generation_offset as usize + 8]
                    .try_into()
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
            ) != parent.model_generation
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        // The successful completed action authenticates the original preflight.
        // Do not recompute its directed-rounding law on the host or read the
        // mutable producer tensor in place of this retained pre-draw snapshot.
        let profile = self.publication_read(profile)?;
        let mut bytes = b"XLOG-ESTIMATOR-BOUND\0".to_vec();
        material_u64(&mut bytes, 1);
        material_u64(&mut bytes, 1); // Native preflight law version.
        material_u64(&mut bytes, 100);
        material_u64(&mut bytes, bank as u64);
        encode_publication_identity(
            &mut bytes,
            SemanticPublishedIdentity {
                instance: parent.instance,
                word: parent.publication_word,
                logical_digest: parent.logical_digest,
                state_digest: parent.state_digest,
            },
        );
        material_u64(&mut bytes, parent.model_generation);
        bytes.extend_from_slice(parent.model_geometry_digest.as_bytes());
        bytes.extend_from_slice(parent.model_numerical_digest.as_bytes());
        bytes.extend_from_slice(domain.as_bytes());
        bind_completed_material(&mut bytes, scoring_law);
        bind_completed_material(&mut bytes, batch_receipt);
        for offset in [layout.schema_digest_offset, layout.identity_offset] {
            bytes.extend_from_slice(&contract[offset as usize..offset as usize + 32]);
        }
        for offset in [
            layout.schema_begin,
            layout.schema_bytes,
            layout.schema_digest_offset,
            layout.generation_offset,
            layout.numerical_digest_offset,
            layout.identity_offset,
        ] {
            material_u64(&mut bytes, offset);
        }
        for material in [&contract, &profile] {
            material_u64(&mut bytes, material.len() as u64);
            bytes.extend_from_slice(material);
        }
        material_u64(&mut bytes, roster.len() as u64);
        for (name, block) in roster.iter().zip(bounds.as_chunks::<6>().0) {
            material_u64(&mut bytes, name.len() as u64);
            bytes.extend_from_slice(name.as_bytes());
            for value in block {
                material_u64(&mut bytes, value.to_bits());
            }
        }
        Ok(Some(completed_action_child_material(
            owner_identity,
            b"estimator-bound",
            0,
            &bytes,
        )))
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_completed_numerical_material(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<SemanticCompletedStepWitnessMaterial, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        let work = self.prepared_completed_step_witnesses(step, consumer_streams)?;
        let action = self.prepared_completed_action_witnesses(step, consumer_streams)?;
        let launches = self
            .captured
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .captured_launch_bindings();
        if launches.is_empty()
            || launches
                .iter()
                .any(|launch| launch.artifact_sha256.is_none())
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let mut graph = Vec::new();
        graph.extend_from_slice(b"XLOG-CAPTURED-CUDA-LAUNCH-BINDINGS\0");
        material_u64(&mut graph, 1);
        material_u64(&mut graph, launches.len() as u64);
        for (ordinal, launch) in launches.iter().enumerate() {
            material_u64(&mut graph, ordinal as u64);
            material_u64(&mut graph, launch.module_name.len() as u64);
            graph.extend_from_slice(launch.module_name.as_bytes());
            material_u64(&mut graph, launch.artifact_name.len() as u64);
            graph.extend_from_slice(launch.artifact_name.as_bytes());
            graph.extend_from_slice(
                launch
                    .artifact_sha256
                    .as_ref()
                    .expect("checked captured artifact identity"),
            );
            material_u64(&mut graph, launch.function_name.len() as u64);
            graph.extend_from_slice(launch.function_name.as_bytes());
            for dimension in [launch.grid_dim.0, launch.grid_dim.1, launch.grid_dim.2] {
                material_u64(&mut graph, dimension as u64);
            }
            for dimension in [launch.block_dim.0, launch.block_dim.1, launch.block_dim.2] {
                material_u64(&mut graph, dimension as u64);
            }
            material_u64(&mut graph, launch.shared_mem_bytes as u64);
            material_u64(&mut graph, launch.parameter_count);
            material_u64(&mut graph, u64::from(launch.cooperative));
        }

        let successor = binding
            .1
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let mut owner_binding = Vec::new();
        owner_binding.extend_from_slice(b"xlog.completed-numerical-realization-owner.v2\0");
        encode_publication_identity(&mut owner_binding, binding.0);
        encode_publication_identity(&mut owner_binding, successor);
        owner_binding.extend_from_slice(work.identity.as_bytes());
        owner_binding.extend_from_slice(action.identity.as_bytes());
        let mut graph_hash = Sha256::new();
        graph_hash.update(&graph);
        owner_binding.extend_from_slice(&graph_hash.finalize());
        material_u64(&mut owner_binding, step.token);
        let mut owner_hash = Sha256::new();
        owner_hash.update(&owner_binding);
        let identity = Identity256::from_bytes(owner_hash.finalize().into());

        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-COMPLETED-NUMERICAL-REALIZATION\0");
        material_u64(&mut bytes, 2);
        material_u64(&mut bytes, graph.len() as u64);
        bytes.extend_from_slice(&graph);
        material_u64(&mut bytes, work.bytes.len() as u64);
        bytes.extend_from_slice(&work.bytes);
        material_u64(&mut bytes, action.bytes.len() as u64);
        bytes.extend_from_slice(&action.bytes);
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticCompletedStepWitnessMaterial { identity, bytes })
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_completed_logits_material(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<SemanticCompletedStepWitnessMaterial, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        if self.completed_prepared_transition_kind(step)? != SemanticTransitionKind::Proposal {
            return Err(publication_input_error(
                "completed logits require an original Proposal",
            ));
        }
        let result_view = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("checked completed step")
            .result
            .view();
        let result = self.publication_read(result_view)?[0];
        let tape_index = self.completed_prepared_policy_tape(step)?;
        let (scores_view, layout) = {
            let policy = &self.policy_tapes[tape_index].policy;
            (policy.retained_scores.view(), policy.layout.clone())
        };
        let scores = self.publication_read(scores_view)?;
        if result.refusal != 0
            || result.advanced != 1
            || scores.len() != layout.retained_score_cells()
            || scores.iter().any(|value| !value.is_finite())
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }

        let successor = binding
            .1
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let mut owner_binding = Vec::new();
        owner_binding.extend_from_slice(b"xlog.completed-logits-owner.v1\0");
        encode_publication_identity(&mut owner_binding, binding.0);
        encode_publication_identity(&mut owner_binding, successor);
        material_u64(&mut owner_binding, step.token);
        let mut owner_hash = Sha256::new();
        owner_hash.update(&owner_binding);
        let identity = Identity256::from_bytes(owner_hash.finalize().into());

        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-COMPLETED-EDIT-LOGITS\0");
        material_u64(&mut bytes, 1);
        material_u64(&mut bytes, (4 * layout.fields.len()) as u64);
        let stride = layout.retained_score_stride();
        let mut next_offset = 0usize;
        let field_offsets = layout
            .fields
            .iter()
            .map(|field| {
                let offset = next_offset;
                next_offset += field.cardinality;
                offset
            })
            .collect::<Vec<_>>();
        for lane in 0..2usize {
            for slot in 0..2usize {
                for (field, field_layout) in layout.fields.iter().enumerate() {
                    let ordinal = lane * 68 + 32 + slot * 18 + field;
                    let offset = (lane * 2 + slot) * stride + field_offsets[field];
                    material_u64(&mut bytes, ordinal as u64);
                    material_u64(&mut bytes, lane as u64);
                    material_u64(&mut bytes, slot as u64);
                    material_u64(&mut bytes, field as u64);
                    material_u64(&mut bytes, field_layout.cardinality as u64);
                    for score in &scores[offset..offset + field_layout.cardinality] {
                        bytes.extend_from_slice(&score.to_bits().to_le_bytes());
                    }
                }
            }
        }
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticCompletedStepWitnessMaterial { identity, bytes })
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_completed_random_material(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<SemanticCompletedStepWitnessMaterial, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        let (header_view, result_view) = {
            let owner = self.checked_prepared_step(step, false)?;
            let inputs = owner
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let prepared = owner.prepared.as_ref().expect("checked prepared owner");
            (inputs.header.view(), prepared.result.view())
        };
        let header = self.publication_read(header_view)?[0];
        let result = self.publication_read(result_view)?[0];
        let tape_index = self.completed_prepared_policy_tape(step)?;
        let receipt_view = self.policy_tapes[tape_index].receipts.view();
        let receipts = self.publication_read(receipt_view)?;
        if result.refusal != 0
            || result.advanced != 1
            || receipts.len() != COMPONENT_COUNT
            || receipts
                .iter()
                .any(|receipt| receipt.proposal != header.proposal)
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }

        let mut owner_binding = Vec::new();
        owner_binding.extend_from_slice(b"xlog.completed-random-state-owner.v1\0");
        encode_publication_identity(&mut owner_binding, binding.0);
        material_u64(&mut owner_binding, step.token);
        let mut owner_hash = Sha256::new();
        owner_hash.update(&owner_binding);
        let identity = Identity256::from_bytes(owner_hash.finalize().into());

        let mut bytes = Vec::new();
        bytes.extend_from_slice(b"XLOG-COMPLETED-RANDOM-STATE\0");
        material_u64(&mut bytes, 1);
        material_u64(&mut bytes, header.model_generation);
        material_u64(&mut bytes, header.stream_serial);
        material_u64(&mut bytes, header.family_id);
        material_u64(&mut bytes, header.proposal);
        material_u64(&mut bytes, header.training_cursor);
        for value in header.training_rng {
            material_u64(&mut bytes, value);
        }
        material_u64(&mut bytes, receipts.len() as u64);
        for receipt in receipts {
            material_u64(&mut bytes, receipt.ordinal as u64);
            material_u64(&mut bytes, receipt.draw);
            for value in receipt.key {
                material_u64(&mut bytes, value as u64);
            }
            for value in receipt.counter {
                material_u64(&mut bytes, value as u64);
            }
            for value in receipt.random_words {
                material_u64(&mut bytes, value as u64);
            }
        }
        if self.prepared_model_binding(step, consumer_streams)? != binding {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticCompletedStepWitnessMaterial { identity, bytes })
    }

    #[cfg(feature = "semantic-policy")]
    pub fn prepared_completed_model_carrier(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<Option<SemanticCompletedModelCarrierMaterial>, SemanticTransitionError> {
        let binding = self.prepared_model_binding(step, consumer_streams)?;
        if self.completed_prepared_transition_kind(step)? != SemanticTransitionKind::Proposal
            || binding.1.is_none()
        {
            return Ok(None);
        }
        Ok(Some(SemanticCompletedModelCarrierMaterial {
            numerical_realization: self
                .prepared_completed_numerical_material(step, consumer_streams)?,
            logits: self.prepared_completed_logits_material(step, consumer_streams)?,
            random_state: self.prepared_completed_random_material(step, consumer_streams)?,
        }))
    }

    /// The caller keeps the builder outside its Session lock while recording
    /// original producers. Retained resources own their preallocated pools.
    pub fn begin_prepared_segment(
        &mut self,
        resources: Vec<Arc<dyn Send + Sync>>,
    ) -> Result<(SemanticPreparedSegmentCapture, Arc<CudaStream>), SemanticTransitionError> {
        self.ensure_quiescent()?;
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        if build.capturing || build.finished {
            return Err(publication_input_error(
                "prepared segment construction already began",
            ));
        }
        let external_floor = build.cold_capacity.external_floor()?;
        if build
            .cold_reservation
            .as_ref()
            .is_none_or(|reservation| reservation.remaining_bytes() != external_floor)
            || build.tokens.iter().any(|token| {
                self.steps
                    .get(token)
                    .and_then(|step| step.prepared.as_ref())
                    .is_none_or(|prepared| {
                        prepared.digests.is_none() || prepared.model_work.is_none()
                    })
            })
        {
            return Err(publication_input_error(
                "prepared segment lacks its complete frozen native cold allocation roster",
            ));
        }
        // Keep the actual pool/model allocations beyond graph retirement for
        // original late consumers. Unknown completion quarantines this same set.
        self.prepared_resources = resources.clone();
        let builder = crate::cuda_graph::ConditionalCudaGraphSequenceBuilder::new_retaining(
            &self.stream,
            resources,
        )
        .map_err(|error| runtime_error("bounded segment capture", error))?;
        let scope = Arc::clone(&build.scope);
        self.prepared_segment
            .as_mut()
            .expect("checked build")
            .capturing = true;
        self.graph.enter_transition();
        Ok((
            SemanticPreparedSegmentCapture { builder, scope },
            Arc::clone(&self.stream),
        ))
    }

    fn check_prepared_content_stream(
        &self,
        step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        if dlpack_consumer_stream(consumer_stream)? != self.stream.cu_stream() {
            return Err(publication_input_error(
                "recorded content must use its original native capture stream",
            ));
        }
        if !self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .inputs_recorded
        {
            return Err(publication_input_error(
                "original step inputs must precede recorded content",
            ));
        }
        Ok(())
    }

    /// Bind the original live model roster cold. Each execution later copies
    /// its expected seals from the actual device-acquired publication.
    pub fn bind_prepared_model_content(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticTensorContentWitness, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        dlpack_consumer_stream(consumer_stream)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared model content bank must be zero or one",
            ));
        }
        if self.steps[&step.token].content.iter().any(|content| {
            matches!(
                &content.seals,
                TensorContentSeals::Model(seals)
                    if seals.prepared.as_ref().is_some_and(|prepared| prepared.bank == bank)
            )
        }) {
            return Err(publication_input_error(
                "prepared model content binds once per original branch bank",
            ));
        }
        let storage = Arc::clone(self.publication.as_ref().expect("prepared publication"));
        let original = prepare_semantic_tensors(&self.provider, tensors)?;
        let directory = &storage.bank_templates[bank];
        let indices = model_content_ranges(
            directory,
            &storage.layouts,
            original.iter().map(|tensor| {
                (
                    tensor.layout,
                    tensor.logical_begin,
                    tensor.logical_end,
                    tensor.source.as_ref().map_or(0, DeviceMemoryView::len),
                )
            }),
        )?;
        let plan = model_content_copy_plan(
            directory,
            &indices,
            &storage
                .allocations
                .iter()
                .map(TrackedCudaSlice::len)
                .collect::<Vec<_>>(),
        )?;
        let values = original
            .iter()
            .flat_map(|tensor| [tensor.layout.role, tensor.layout.index])
            .collect::<Vec<_>>();
        let provider = Arc::clone(&self.provider);
        let allocated = (|| {
            let reservation = self
                .prepared_segment
                .as_mut()
                .expect("checked prepared segment")
                .cold_reservation
                .as_mut()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let seals = ModelContentSeals::allocate_reserved(&provider, &plan, reservation)?;
            let roster = reservation
                .alloc::<u64>(values.len())
                .map_err(|error| runtime_error("prepared model roster allocation", error))?;
            Ok::<_, SemanticTransitionError>((seals, roster))
        })();
        let (mut seals, roster) = match allocated {
            Ok(allocated) => allocated,
            Err(error) => {
                self.poisoned = true;
                return Err(error);
            }
        };
        #[cfg(feature = "semantic-policy")]
        let execute = self
            .provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_publication_model_seals",
            )
            .ok_or_else(|| {
                runtime_error("kernel lookup", "original model seal snapshot unavailable")
            })?;
        #[cfg(feature = "semantic-policy")]
        let reader = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared lease")
            .reader
            .view();
        seals.prepared = Some(PreparedModelContentSeals {
            bank,
            #[cfg(feature = "semantic-policy")]
            storage,
            #[cfg(feature = "semantic-policy")]
            reader,
            roster,
            #[cfg(feature = "semantic-policy")]
            execute,
        });
        let owner = self.steps.get_mut(&step.token).expect("checked fixed step");
        owner.consumer_streams.insert(consumer_stream);
        let index = owner.content.len();
        owner.content.push(TensorContentBuffers {
            tensors: original,
            seals: TensorContentSeals::Model(seals),
            verification_inputs: Vec::new(),
        });
        let handle = SemanticTensorContentWitness {
            issuer: Arc::clone(&self.publication_issuer),
            reader_token: step.token,
            index,
            _witness: Arc::clone(&owner.content_witnesses),
        };
        let TensorContentSeals::Model(seals) = &owner.content[index].seals else {
            unreachable!("installed original model seals")
        };
        if let Err(error) = upload_publication(
            &self.provider,
            &values,
            &seals
                .prepared
                .as_ref()
                .expect("installed original roster")
                .roster,
        ) {
            self.poisoned = true;
            return Err(error);
        }
        Ok(handle)
    }

    /// Authenticate and retain the original physical tensor rows used by one
    /// prepared bank's AccumulateGrad delivery owner. Every row must be the
    /// exact typed alias of that bank's roles 18 through 25.
    pub fn bind_prepared_gradient_delivery(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticGradientDeliveryBinding, SemanticTransitionError> {
        self.bind_gradient_delivery(step, bank, tensors, consumer_stream, None)
    }

    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "gradient delivery retains the destination bank, original source reader and exact member invocation"
    )]
    pub fn bind_imported_group_gradient_delivery(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        source: &SemanticTransitionSession,
        source_lease: &SemanticPublishedLease,
        invocation: SemanticRngBinding,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticGradientDeliveryBinding, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        if bank > 1 {
            return Err(publication_input_error(
                "group gradient delivery requires bank zero or one",
            ));
        }
        source.checked_reader(source_lease)?;
        if std::ptr::eq(self, source)
            || self.provider.device().ordinal() != source.provider.device().ordinal()
            || source.policy_tapes.iter().all(|tape| {
                tape.invocation != invocation
                    || tape.refusal.is_some()
                    || tape.prepared_bank.is_some()
                    || tape.policy.text_binding._witness.reader_token != source_lease.token
            })
        {
            return Err(publication_input_error(
                "group gradient delivery requires the original published policy on a distinct same-device Session",
            ));
        }
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("checked prepared step");
        if prepared.group_gradient_members[bank].contains(&member_ordinal) {
            return Err(publication_input_error(
                "original replay already owns this Update bank's physical gradient delivery",
            ));
        }
        let training = prepared.training_view.as_ref().ok_or_else(|| {
            publication_input_error(
                "group gradient delivery requires the frozen Update training view",
            )
        })?;
        if training
            .actor_group_member_index(member_ordinal, member_row)
            .is_err()
            && training
                .edit_group_member_index(member_ordinal, member_row)?
                .is_none()
        {
            return Err(publication_input_error(
                "original replay is absent from the frozen actor and edit groups",
            ));
        }
        let model = source.steps[&source_lease.token]
            .content
            .iter()
            .filter(|content| matches!(&content.seals, TensorContentSeals::Model(_)))
            .collect::<Vec<_>>();
        let [model] = model.as_slice() else {
            return Err(publication_input_error(
                "original replay has no unique authenticated physical model roster",
            ));
        };
        let binding = self.bind_gradient_delivery(
            step,
            bank,
            tensors,
            consumer_stream,
            Some(&model.tensors),
        )?;
        self.steps
            .get_mut(&step.token)
            .expect("checked prepared step")
            .prepared
            .as_mut()
            .expect("checked prepared owner")
            .group_gradient_members[bank]
            .insert(member_ordinal);
        Ok(binding)
    }

    fn bind_gradient_delivery(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
        foreign_model: Option<&[PreparedSemanticTensor]>,
    ) -> Result<SemanticGradientDeliveryBinding, SemanticTransitionError> {
        self.check_prepared_cold(step)?;
        dlpack_consumer_stream(consumer_stream)?;
        if bank > 1 || tensors.is_empty() {
            return Err(publication_input_error(
                "gradient delivery requires one prepared bank and a nonempty physical roster",
            ));
        }
        let imported = prepare_semantic_tensors(&self.provider, tensors)?;
        let inputs = self.steps[&step.token]
            .inputs
            .as_ref()
            .expect("fixed input owner");
        for tensor in &imported {
            let authentic = if let Some(model) =
                foreign_model.filter(|_| (18..=20).contains(&tensor.layout.role))
            {
                model
                    .iter()
                    .any(|original| same_tensor_content_owner(original, tensor))
            } else {
                inputs.owns_bank_model_tensor(bank, tensor)?
            };
            if !authentic {
                return Err(publication_input_error(
                    "gradient delivery input differs from its authenticated model or prepared bank tensor",
                ));
            }
        }
        if let Some(model) = foreign_model {
            let expected = model
                .iter()
                .filter(|tensor| (18..=20).contains(&tensor.layout.role))
                .map(|tensor| (tensor.layout.role, tensor.layout.index))
                .collect::<BTreeSet<_>>();
            let actual_rows = imported
                .iter()
                .filter(|tensor| (18..=20).contains(&tensor.layout.role));
            let actual = actual_rows
                .clone()
                .map(|tensor| (tensor.layout.role, tensor.layout.index))
                .collect::<BTreeSet<_>>();
            if actual != expected || actual_rows.count() != actual.len() {
                return Err(publication_input_error(
                    "group gradient delivery requires every original physical model leaf exactly once",
                ));
            }
        }
        for role in [
            SemanticStateRole::Gradients as u64,
            SemanticStateRole::GradientAccumulation as u64,
        ] {
            let expected = inputs
                .plans
                .iter()
                .filter(|input| input.role == role)
                .map(|input| (input.role, input.index))
                .collect::<BTreeSet<_>>();
            let actual_rows = imported.iter().filter(|tensor| tensor.layout.role == role);
            let actual = actual_rows
                .clone()
                .map(|tensor| (tensor.layout.role, tensor.layout.index))
                .collect::<BTreeSet<_>>();
            if actual != expected || actual_rows.count() != actual.len() {
                return Err(publication_input_error(
                    "gradient delivery requires every canonical gradient and presence input exactly once",
                ));
            }
        }
        let is_phase_mask = |layout: &SemanticTensorLayout| {
            layout.role == SemanticStateRole::TrainingSchedule as u64
                && layout.element_bytes == 1
                && layout.scalar_type == 8
                && layout.rank == 1
                && layout.logical_axis == u64::MAX
                && layout.dimensions == [3, 0, 0, 0]
                && layout.strides_bytes == [1, 0, 0, 0]
        };
        let expected_phase_masks = inputs
            .plans
            .iter()
            .filter(|input| is_phase_mask(&input.layout))
            .map(|input| (input.role, input.index))
            .collect::<BTreeSet<_>>();
        let actual_phase_mask_rows = imported
            .iter()
            .filter(|tensor| is_phase_mask(&tensor.layout));
        let actual_phase_masks = actual_phase_mask_rows
            .clone()
            .map(|tensor| (tensor.layout.role, tensor.layout.index))
            .collect::<BTreeSet<_>>();
        if actual_phase_masks != expected_phase_masks
            || actual_phase_mask_rows.count() != actual_phase_masks.len()
        {
            return Err(publication_input_error(
                "gradient delivery requires every canonical phase mask exactly once",
            ));
        }
        self.steps
            .get_mut(&step.token)
            .expect("checked gradient-delivery step")
            .consumer_streams
            .insert(consumer_stream);
        Ok(SemanticGradientDeliveryBinding { _tensors: imported })
    }

    /// Attach actual original output owners as they are born during recording.
    /// Every private digest cell already exists; this operation cannot allocate
    /// device storage or establish a second baseline for native producer aliases.
    pub fn capture_prepared_tensor_content(
        &mut self,
        step: &SemanticPreparedStep,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticTensorContentWitness, SemanticTransitionError> {
        self.check_prepared_content_stream(step, consumer_stream)?;
        if tensors.is_empty() {
            return Err(publication_input_error(
                "original content requires an actual tensor roster",
            ));
        }
        let original = prepare_semantic_tensors(&self.provider, tensors)?;
        // Retain actual producers before validating coordinates or consuming
        // a reserved digest. Recording failure poisons this construction.
        let owner = self.steps.get_mut(&step.token).expect("checked fixed step");
        let index = owner.content.len();
        owner.content.push(TensorContentBuffers {
            tensors: original,
            seals: TensorContentSeals::Captured(Vec::new()),
            verification_inputs: Vec::new(),
        });
        let result = (|| {
            let owner = &self.steps[&step.token];
            let original = &owner.content[index].tensors;
            validate_content_coordinates(
                original
                    .iter()
                    .map(|tensor| (tensor.layout.role, tensor.layout.index)),
            )?;
            let mut digests = Vec::with_capacity(original.len());
            let prepared = owner.prepared.as_ref().expect("prepared content owner");
            let mut next = prepared.next_digest;
            for tensor in original {
                let mut native = owner.feedback_origin_digest(tensor)?;
                if native.is_none() {
                    let inputs = owner.inputs.as_ref().expect("fixed step inputs");
                    if inputs.owns_tensor(tensor)? {
                        native = Some(CapturedTensorDigest::Publication(Arc::clone(inputs)));
                    }
                }
                if let Some(native) = native {
                    digests.push(native);
                    continue;
                }
                for (&token, other) in &self.steps {
                    if token == step.token {
                        continue;
                    }
                    let other_input = match &other.inputs {
                        Some(inputs) => inputs.owns_tensor(tensor)?,
                        None => false,
                    };
                    if other.feedback_origin_digest(tensor)?.is_some() || other_input {
                        return Err(publication_input_error(
                            "original content belongs to another native prepared step",
                        ));
                    }
                }
                if tensor.native_allocation.is_some() {
                    return Err(publication_input_error("native allocation origin has no original content producer in this prepared step"));
                }
                tensor_content_range(
                    &tensor.layout,
                    tensor.logical_begin,
                    tensor.logical_end,
                    tensor.source.as_ref().map_or(0, DeviceMemoryView::len),
                )?;
                let cells = prepared
                    .digests
                    .as_ref()
                    .filter(|cells| next < cells.len() / 4)
                    .ok_or_else(|| {
                        publication_input_error(
                            "original tensor roster exceeds its cold native content reservation",
                        )
                    })?;
                let offset = next * 4;
                next += 1;
                digests.push(CapturedTensorDigest::Tensor {
                    cells: Arc::clone(cells),
                    offset,
                    producer_sealed: false,
                });
            }
            let owner = self.steps.get_mut(&step.token).expect("checked fixed step");
            owner
                .prepared
                .as_mut()
                .expect("prepared content owner")
                .next_digest = next;
            owner.content[index].seals = TensorContentSeals::Captured(digests);
            let handle = SemanticTensorContentWitness {
                issuer: Arc::clone(&self.publication_issuer),
                reader_token: step.token,
                index,
                _witness: Arc::clone(&owner.content_witnesses),
            };
            self.record_prepared_tensor_content(step, &handle, false)?;
            Ok(handle)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    fn checked_prepared_content_witness(
        &self,
        step: &SemanticPreparedStep,
        witness: &SemanticTensorContentWitness,
    ) -> Result<(), SemanticTransitionError> {
        let owner = self.checked_prepared_step(step, false)?;
        if witness.reader_token != step.token
            || !Arc::ptr_eq(&witness.issuer, &self.publication_issuer)
            || !Arc::ptr_eq(&witness._witness, &owner.content_witnesses)
            || witness.index >= owner.content.len()
        {
            return Err(publication_input_error(
                "original content witness belongs to another native prepared step",
            ));
        }
        Ok(())
    }

    pub fn record_prepared_tensor_content(
        &mut self,
        step: &SemanticPreparedStep,
        witness: &SemanticTensorContentWitness,
        verify: bool,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        self.checked_prepared_content_witness(step, witness)?;
        let owner = &self.steps[&step.token];
        let execute = &owner
            .prepared
            .as_ref()
            .expect("prepared content owner")
            .witness;
        owner.content[witness.index].enqueue(&self.domain, &mut self.poisoned, execute, verify)
    }

    /// Bind original forward outputs after their private witness was recorded.
    /// Numerical copies and native continuation preparation are recorded later
    /// by the complete step body; fresh authority bytes are uploaded at submit.
    /// Proposal blocks retain this bank's original model-content witness; their
    /// schema and identity come from its acquired device snapshot on each replay.
    pub fn bind_prepared_continuation(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        continuation: SemanticContinuationInput,
        witness: &SemanticTensorContentWitness,
        model_content_witness: Option<&SemanticTensorContentWitness>,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, consumer_stream)?;
        self.checked_prepared_content_witness(step, witness)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared continuation bank must be zero or one",
            ));
        }
        if self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .branches[bank]
            .continuation
            .is_some()
        {
            return Err(publication_input_error(
                "original prepared continuation binds once",
            ));
        }
        if !matches!(
            self.steps[&step.token].content[witness.index].seals,
            TensorContentSeals::Captured(_)
        ) {
            return Err(publication_input_error(
                "continuation requires its original transient producer witness",
            ));
        }
        let storage = Arc::clone(self.publication.as_ref().expect("prepared publication"));
        let tensor_count = continuation.tensors.len();
        let capacity = storage
            .contract_value
            .feedback_capacity
            .checked_add(32)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let kind = self.prepared_transition_kind(step)?;
        let (physical_blocks, model_schema_digest, model_identity) =
            storage.continuation_block_contract(kind, &continuation, true)?;
        let model_contract = match (physical_blocks, model_content_witness) {
            (None, None) => None,
            (Some(_), Some(model_witness)) => {
                self.checked_prepared_content_witness(step, model_witness)?;
                let owner = &self.steps[&step.token];
                let TensorContentSeals::Model(seals) = &owner.content[model_witness.index].seals else {
                    return Err(publication_input_error(
                        "prepared block bounds require their original model-content witness",
                    ));
                };
                let prepared = owner.prepared.as_ref().expect("prepared model owner");
                if seals.prepared.as_ref().is_none_or(|source| source.bank != bank)
                    || prepared.model_content_recorded & (1 << bank) == 0
                {
                    return Err(publication_input_error(
                        "prepared block bounds require the same bank's recorded model-content guard",
                    ));
                }
                // This is the existing private role44 snapshot, refreshed by
                // the original acquire guard before this bank's model reads.
                // Retain its witness below; never read identities on the host.
                Some(seals.contract.view())
            }
            _ => return Err(publication_input_error(
                "prepared proposal blocks and their model-content witness must be supplied together",
            )),
        };
        let service_layouts =
            continuation_service_layouts(tensor_count, capacity, physical_blocks)?;
        let SemanticContinuationInput {
            mut tensors,
            authority_decisions,
            text_rows,
            text_row_count,
            selected_text,
            active_rows,
            active_row_count,
            numerical_admissibility,
            numerical_blocks,
            model_schema_digest: _,
            model_identity: _,
        } = continuation;
        if authority_decisions.is_empty() {
            return Err(publication_input_error(
                "continuation requires its original authority snapshot geometry",
            ));
        }
        let mut services = vec![
            text_rows,
            text_row_count,
            selected_text,
            active_rows,
            active_row_count,
            numerical_admissibility,
        ];
        services.extend(numerical_blocks);
        tensors.extend(
            services
                .into_iter()
                .zip(service_layouts)
                .map(|(tensor, layout)| SemanticTensorInput {
                    tensor,
                    layout,
                    logical_begin: 0,
                    logical_end: 0,
                    native_allocation: None,
                }),
        );
        self.verify_prepared_tensor_content(step, witness, tensors, consumer_stream)?;
        let numerical_block_snapshot = if physical_blocks.is_some() {
            let original =
                self.steps[&step.token].content[witness.index].tensors[tensor_count + 6].clone();
            let snapshot = Arc::clone(
                self.steps[&step.token]
                    .prepared
                    .as_ref()
                    .expect("prepared owner")
                    .branches[bank]
                    .numerical_block_snapshot
                    .as_ref()
                    .ok_or_else(|| {
                        publication_input_error(
                            "prepared block bounds lack their reserved native slot",
                        )
                    })?,
            );
            enqueue_numerical_block_snapshot(
                &self.domain,
                &mut self.poisoned,
                &original,
                &snapshot,
            )?;
            Some(snapshot)
        } else {
            None
        };
        let owner = &self.steps[&step.token];
        let original = &owner.content[witness.index].tensors;
        let services = original[tensor_count..].to_vec();
        if services.len() != 6 + usize::from(physical_blocks.is_some()) {
            return Err(publication_input_error(
                "continuation witness has the wrong original service roster",
            ));
        }
        let binding = Arc::new(TextBindingStorage {
            inputs: services,
            numerical_block_snapshot,
            model_contract,
            physical_blocks: physical_blocks.unwrap_or(0) as u64,
            model_schema_digest,
            model_identity,
            _witness: witness.clone(),
            _model_content_witness: model_content_witness.cloned(),
            consumer_stream,
            parent: TextBindingParent::Prepared(Arc::clone(
                owner.inputs.as_ref().expect("fixed inputs"),
            )),
        });
        let kind = self
            .prepared_segment
            .as_ref()
            .expect("prepared scope")
            .requested_kind(step, &self.publication_issuer)?;
        let (uploads, layouts) = prepare_continuation_payloads(
            &storage,
            &original[..tensor_count],
            &authority_decisions,
            kind,
        )?;
        let training_selection = match (
            kind,
            owner
                .prepared
                .as_ref()
                .expect("prepared selection owner")
                .training_view
                .as_ref(),
        ) {
            (SemanticTransitionKind::Update, Some(view)) => Some(view.selection()),
            (SemanticTransitionKind::Update, None) => {
                return Err(publication_input_error(
                    "prepared update continuation has no native training selection",
                ));
            }
            (_, None) => None,
            (_, Some(_)) => {
                return Err(publication_input_error(
                    "non-update continuation owns an unexpected training selection",
                ));
            }
        };
        let training_selection_pointer = training_selection
            .as_ref()
            .map_or(0, |selection| *selection.device_ptr());
        let model_update = owner
            .prepared
            .as_ref()
            .expect("prepared model update owner")
            .branches[bank]
            .model_update
            .as_ref()
            .map(PreparedModelUpdate::descriptor)
            .unwrap_or_default();
        let continuation = PreparedContinuation::prepare(
            &self.provider,
            storage,
            owner
                .prepared
                .as_ref()
                .expect("prepared lease")
                .reader
                .view(),
            Arc::clone(&binding),
            binding.continuation_inputs(
                kind,
                authority_decisions.len() as u64,
                training_selection_pointer,
                model_update,
            ),
            training_selection,
            &uploads,
            &layouts,
        )?;
        self.steps
            .get_mut(&step.token)
            .expect("checked prepared step")
            .prepared
            .as_mut()
            .expect("prepared owner")
            .branches[bank]
            .continuation = Some(continuation);
        #[cfg(feature = "semantic-policy")]
        self.attach_prepared_policy_continuation(step, bank)?;
        Ok(())
    }

    /// Bind the complete producer-owned model backing after the original
    /// selected-view backward and optimizer update were recorded. The output is
    /// copied into the inactive neural bank by a prepared CUDA node before the
    /// sole publication transition commits its pointer and generation state.
    /// Record one baseline or candidate forward at the actual producer site.
    /// The receipt node is inserted into the active prepared bank capture and
    /// cannot be reconstructed later from handoff argument position.
    pub fn record_prepared_model_forward(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        role: usize,
        logits: SemanticTensorInput,
        consumer_stream: u64,
    ) -> Result<SemanticModelForwardWitness, SemanticTransitionError> {
        self.check_prepared_content_stream(step, consumer_stream)?;
        if bank > 1 || role > 1 {
            return Err(publication_input_error(
                "prepared model forward bank and role must be zero or one",
            ));
        }
        if self.prepared_transition_kind(step)? != SemanticTransitionKind::Update {
            return Err(publication_input_error(
                "model forward receipts belong only to a prepared update",
            ));
        }
        let content = self.capture_prepared_tensor_content(step, vec![logits], consumer_stream)?;
        let storage = Arc::clone(self.publication.as_ref().expect("prepared publication"));
        let owner = self
            .steps
            .get_mut(&step.token)
            .expect("checked update step");
        let prepared = owner.prepared.as_mut().expect("prepared update owner");
        if prepared
            .model_work
            .as_ref()
            .is_none_or(|work| work.capture_bank != Some(bank))
        {
            return Err(publication_input_error(
                "model forward receipt requires the active producer bank capture",
            ));
        }
        let training_view = prepared.training_view.as_ref().ok_or_else(|| {
            publication_input_error("prepared update has no native training view")
        })?;
        let work_sequence = prepared
            .model_work
            .as_ref()
            .expect("active model work checked above")
            .next_slot()
            .map_err(publication_input_error)?;
        if work_sequence == 0 {
            return Err(publication_input_error(
                "model forward receipt requires recorded producer work before the logits occurrence",
            ));
        }
        let tensor = owner.content[content.index]
            .tensors
            .first()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .clone();
        let layout = tensor.layout;
        let row_count = training_view.roster_rows().len() as u64;
        let capacity = training_view.capacity() as u64;
        if !matches!(
            (layout.scalar_type, layout.element_bytes),
            (4, 2) | (5, 2) | (6, 4)
        ) || layout.role != 0
            || layout.index != role as u64
            || layout.rank != 3
            || layout.logical_axis != u64::MAX
            || layout.dimensions[0] != row_count
            || layout.dimensions[1] != capacity
            || layout.dimensions[2] == 0
            || layout.dimensions[3] != 0
            || layout.strides_bytes[2] != layout.element_bytes
            || layout.strides_bytes[1]
                != layout.dimensions[2]
                    .checked_mul(layout.element_bytes)
                    .unwrap_or(0)
            || layout.strides_bytes[0]
                != layout.dimensions[1]
                    .checked_mul(layout.strides_bytes[1])
                    .unwrap_or(0)
            || layout.strides_bytes[3] != 0
            || tensor.logical_begin != 0
            || tensor.logical_end != 0
        {
            return Err(publication_input_error(
                "model forward logits must be aligned contiguous F16/BF16/F32 [rows,capacity,vocabulary] with its explicit role",
            ));
        }
        let TensorContentSeals::Captured(digests) = &owner.content[content.index].seals else {
            return Err(SemanticTransitionError::ObservationMismatch);
        };
        let (logits_digest, digest_cells) = captured_tensor_digest_pointer(digests, 0)?;
        let update = prepared.branches[bank]
            .model_update
            .as_mut()
            .ok_or_else(|| publication_input_error("prepared branch has no model update"))?;
        if update.forward_recorded != role as u8 {
            return Err(publication_input_error(
                "model forwards must be recorded exactly once in baseline then candidate order",
            ));
        }
        update.forward_recorded += 1;
        let receipt = update.forward_receipts.device_ptr_value()
            + (role * size_of::<ModelForwardReceipt>()) as u64;
        let inputs = ModelForwardReceiptInputs {
            control: storage.control.device_ptr_value(),
            lease: prepared.reader.device_ptr_value(),
            candidate_seals: update.forward_seals.device_ptr_value(),
            candidate_seal_count: update.forward_seals.len() as u64,
            role: role as u64,
            work_sequence: work_sequence as u64,
            logits: tensor.data,
            scalar_type: layout.scalar_type,
            row_count,
            capacity,
            vocabulary: layout.dimensions[2],
            row_stride_bytes: layout.strides_bytes[0],
            position_stride_bytes: layout.strides_bytes[1],
            vocabulary_stride_bytes: layout.strides_bytes[2],
            logits_digest,
            receipt,
        };
        let mut recorder = self.domain.new_strict_recorder();
        storage.record(&mut recorder);
        recorder.read(&prepared.reader);
        recorder.read(&update.forward_seals);
        recorder.read(digest_cells.as_ref());
        recorder.write(&update.forward_receipts);
        let result = enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: all pointers name retained native or producer-owned storage;
            // the launch is captured immediately after the actual forward.
            unsafe {
                update.forward_receipt.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (inputs,),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        });
        if result.is_err() {
            self.poisoned = true;
        }
        result?;
        Ok(SemanticModelForwardWitness {
            issuer: Arc::clone(&self.publication_issuer),
            reader_token: step.token,
            bank,
            role,
            content,
        })
    }

    #[expect(
        clippy::too_many_arguments,
        reason = "the native update handoff binds model geometry, numerical validity and canary evidence"
    )]
    pub fn bind_prepared_update_output(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        mut model_memory: SemanticModelMemory,
        mut tensors: Vec<SemanticTensorInput>,
        admissibility: SemanticTensorInput,
        slab_backing: SemanticTensorInput,
        baseline_forward: &SemanticModelForwardWitness,
        candidate_forward: &SemanticModelForwardWitness,
        witness: &SemanticTensorContentWitness,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, consumer_stream)?;
        self.checked_prepared_content_witness(step, witness)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared model update bank must be zero or one",
            ));
        }
        for (role, forward) in [(0, baseline_forward), (1, candidate_forward)] {
            if !Arc::ptr_eq(&forward.issuer, &self.publication_issuer)
                || forward.reader_token != step.token
                || forward.bank != bank
                || forward.role != role
            {
                return Err(publication_input_error(
                    "model update requires exact producer-issued baseline and candidate forward witnesses",
                ));
            }
        }
        if self.prepared_transition_kind(step)? != SemanticTransitionKind::Update {
            return Err(publication_input_error(
                "model update output belongs only to a prepared update",
            ));
        }
        if self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared update owner")
            .branches[bank]
            .model_update
            .as_ref()
            .is_none_or(|update| update.output.is_some())
        {
            return Err(publication_input_error(
                "prepared update output binds exactly once",
            ));
        }
        if !matches!(
            self.steps[&step.token].content[witness.index].seals,
            TensorContentSeals::Captured(_)
        ) {
            return Err(publication_input_error(
                "model update output requires its original transient producer witness",
            ));
        }
        let allocation_count = model_memory.allocations.len();
        if allocation_count == 0 {
            return Err(publication_input_error(
                "model update output requires complete backing allocations",
            ));
        }
        let tensor_count = tensors.len();
        model_memory.allocations.append(&mut tensors);
        model_memory.allocations.push(admissibility);
        self.verify_prepared_tensor_content(
            step,
            witness,
            model_memory.allocations,
            consumer_stream,
        )?;
        let storage = Arc::clone(self.publication.as_ref().expect("prepared publication"));
        let outputs = self.steps[&step.token].content[witness.index]
            .tensors
            .clone();
        let (allocations, outputs) = outputs.split_at(allocation_count);
        let (tensors, update_metadata) = outputs.split_at(tensor_count);
        let [admissibility] = update_metadata else {
            return Err(publication_input_error(
                "model update output requires numerical admissibility",
            ));
        };
        let forward_tensor = |forward: &SemanticModelForwardWitness| {
            self.steps[&step.token].content[forward.content.index]
                .tensors
                .first()
                .cloned()
                .ok_or(SemanticTransitionError::ObservationMismatch)
        };
        let baseline_logits = forward_tensor(baseline_forward)?;
        let candidate_logits = forward_tensor(candidate_forward)?;
        let allocation_index = u64::try_from(allocation_count)
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        if admissibility.layout
            != (SemanticTensorLayout {
                role: 0,
                index: allocation_index,
                element_bytes: 1,
                scalar_type: 8,
                rank: 1,
                logical_axis: u64::MAX,
                dimensions: [1, 0, 0, 0],
                strides_bytes: [1, 0, 0, 0],
            })
            || admissibility.logical_begin != 0
            || admissibility.logical_end != 0
        {
            return Err(publication_input_error(
                "model update numerical admissibility must be Bool8[1]",
            ));
        }
        let training_view = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared update owner")
            .training_view
            .as_ref()
            .ok_or_else(|| {
                publication_input_error("prepared update has no native training view")
            })?;
        let row_count = training_view.roster_rows().len() as u64;
        let capacity = training_view.capacity() as u64;
        let layout_valid = |tensor: &PreparedSemanticTensor, index: u64| {
            let layout = tensor.layout;
            matches!(layout.scalar_type, 4..=6)
                && matches!(
                    (layout.scalar_type, layout.element_bytes),
                    (4, 2) | (5, 2) | (6, 4)
                )
                && layout.role == 0
                && layout.index == index
                && layout.rank == 3
                && layout.logical_axis == u64::MAX
                && layout.dimensions[0] == row_count
                && layout.dimensions[1] == capacity
                && layout.dimensions[2] > 0
                && layout.dimensions[3] == 0
                && layout.strides_bytes[2] == layout.element_bytes
                && layout.strides_bytes[1]
                    == layout.dimensions[2]
                        .checked_mul(layout.element_bytes)
                        .unwrap_or(0)
                && layout.strides_bytes[0]
                    == layout.dimensions[1]
                        .checked_mul(layout.strides_bytes[1])
                        .unwrap_or(0)
                && layout.strides_bytes[3] == 0
                && tensor.logical_begin == 0
                && tensor.logical_end == 0
        };
        if !layout_valid(&baseline_logits, 0)
            || !layout_valid(&candidate_logits, 1)
            || baseline_logits.layout.scalar_type != candidate_logits.layout.scalar_type
            || baseline_logits.layout.dimensions != candidate_logits.layout.dimensions
            || baseline_logits.layout.strides_bytes != candidate_logits.layout.strides_bytes
        {
            return Err(publication_input_error(
                "model update canary logits must be aligned contiguous F16/BF16/F32 [rows,capacity,vocabulary]",
            ));
        }
        let geometry = prepare_model_memory(
            allocations,
            model_memory.storages,
            model_memory.views,
            tensors,
        )?;
        let actual_layouts = tensors
            .iter()
            .map(|tensor| ((tensor.layout.role, tensor.layout.index), tensor.layout))
            .collect::<BTreeMap<_, _>>();
        let expected_layouts = storage
            .layouts
            .iter()
            .filter(|((role, _), _)| matches!(role, 18..=25))
            .map(|(key, layout)| (*key, *layout))
            .collect::<BTreeMap<_, _>>();
        if geometry != storage.model_memory || actual_layouts != expected_layouts {
            return Err(publication_input_error(
                "model update output differs from the acquired model memory contract",
            ));
        }
        let TensorContentSeals::Captured(digests) =
            &self.steps[&step.token].content[witness.index].seals
        else {
            return Err(SemanticTransitionError::ObservationMismatch);
        };
        let mut forward_seal_values = Vec::new();
        let mut digest_cells = Vec::new();
        for range in storage.bank_templates[0]
            .iter()
            .filter(|range| matches!(range.role, 18..=25))
        {
            let tensor_index = tensors
                .iter()
                .position(|tensor| {
                    (tensor.layout.role, tensor.layout.index) == (range.role, range.index)
                })
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let (allocation_index, _) = geometry.location(range.role, range.index)?;
            let (tensor_digest, tensor_cells) =
                captured_tensor_digest_pointer(digests, allocation_count + tensor_index)?;
            let (backing_digest, backing_cells) =
                captured_tensor_digest_pointer(digests, allocation_index)?;
            forward_seal_values.push(ModelForwardSealInput {
                role: range.role,
                index: range.index,
                tensor_digest,
                backing_digest,
            });
            digest_cells.push(tensor_cells);
            digest_cells.push(backing_cells);
        }
        let forward_digest = |forward: &SemanticModelForwardWitness| {
            let TensorContentSeals::Captured(digests) =
                &self.steps[&step.token].content[forward.content.index].seals
            else {
                return Err(SemanticTransitionError::ObservationMismatch);
            };
            captured_tensor_digest_pointer(digests, 0)
        };
        let (_, baseline_digest_cells) = forward_digest(baseline_forward)?;
        let (_, candidate_digest_cells) = forward_digest(candidate_forward)?;
        digest_cells.push(baseline_digest_cells);
        digest_cells.push(candidate_digest_cells);
        for allocation in allocations {
            let bytes = tensor_layout_bytes(&allocation.layout)?;
            if step_input_overlap(allocation.data, bytes, admissibility.data, 1)? {
                return Err(publication_input_error(
                    "model update numerical admissibility aliases an output allocation",
                ));
            }
            let logits_bytes = tensor_layout_bytes(&baseline_logits.layout)?;
            if step_input_overlap(allocation.data, bytes, baseline_logits.data, logits_bytes)?
                || step_input_overlap(allocation.data, bytes, candidate_logits.data, logits_bytes)?
            {
                return Err(publication_input_error(
                    "model update canary logits alias an output allocation",
                ));
            }
            for owned in &storage.allocations {
                if step_input_overlap(
                    allocation.data,
                    bytes,
                    owned.device_ptr_value(),
                    owned.len(),
                )? {
                    return Err(publication_input_error(
                        "model update output aliases native publication storage",
                    ));
                }
            }
        }
        let logits_bytes = tensor_layout_bytes(&baseline_logits.layout)?;
        if step_input_overlap(admissibility.data, 1, baseline_logits.data, logits_bytes)?
            || step_input_overlap(admissibility.data, 1, candidate_logits.data, logits_bytes)?
            || step_input_overlap(
                baseline_logits.data,
                logits_bytes,
                candidate_logits.data,
                logits_bytes,
            )?
        {
            return Err(publication_input_error(
                "model update canary logits alias one another or numerical admissibility",
            ));
        }
        for owned in &storage.allocations {
            if step_input_overlap(
                baseline_logits.data,
                logits_bytes,
                owned.device_ptr_value(),
                owned.len(),
            )? || step_input_overlap(
                candidate_logits.data,
                logits_bytes,
                owned.device_ptr_value(),
                owned.len(),
            )? {
                return Err(publication_input_error(
                    "model update canary logits alias native publication storage",
                ));
            }
        }
        let values = allocations
            .iter()
            .zip(&storage.model_slots)
            .zip(&geometry.allocation_bytes)
            .map(|((allocation, slots), &bytes)| ModelUpdateBinding {
                source: allocation.data,
                bytes,
                slots: [slots[0] as u64, slots[1] as u64],
            })
            .collect::<Vec<_>>();
        let retained_allocations = allocations.to_vec();
        let mut slab = prepare_semantic_tensors(&self.provider, vec![slab_backing])?;
        let slab = slab
            .pop()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if slab.layout.role != 0
            || slab.layout.index != 0
            || slab.layout.scalar_type != 1
            || slab.layout.element_bytes != 1
            || slab.layout.rank != 1
            || slab.layout.logical_axis != u64::MAX
            || slab.layout.dimensions[0] == 0
            || slab.layout.dimensions[1..] != [0, 0, 0]
            || slab.layout.strides_bytes != [1, 0, 0, 0]
            || slab.logical_begin != 0
            || slab.logical_end != 0
        {
            return Err(publication_input_error(
                "update slab must be its original contiguous CUDA UInt8 allocation",
            ));
        }
        #[cfg(feature = "semantic-policy")]
        let accounted_reserved_bytes = accounted_tensor_allocations(
            &outputs
                .iter()
                .chain([&baseline_logits, &candidate_logits])
                .collect::<Vec<_>>(),
            &slab,
        )?;
        #[cfg(feature = "semantic-policy")]
        let copy_bytes = values.iter().try_fold(0u64, |total, binding| {
            total
                .checked_add(binding.bytes)
                .ok_or(SemanticTransitionError::GenerationExhausted)
        })?;
        let prepared = self
            .steps
            .get_mut(&step.token)
            .expect("checked update step");
        let update = prepared
            .prepared
            .as_mut()
            .expect("prepared update owner")
            .branches[bank]
            .model_update
            .as_mut()
            .expect("prepared update binding allocation");
        if values.len() != update.bindings.len() {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        if forward_seal_values.len() != update.forward_seals.len() {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        if update.forward_recorded != 2 {
            return Err(publication_input_error(
                "model update output requires both producer-issued forward receipts",
            ));
        }
        update.output = Some(BoundModelUpdate {
            values,
            forward_seal_values,
            digest_cells,
            allocations: retained_allocations,
            admissibility: admissibility.clone(),
            baseline_logits,
            candidate_logits,
            _slab_backing: slab,
            #[cfg(feature = "semantic-policy")]
            accounted_reserved_bytes,
            #[cfg(feature = "semantic-policy")]
            copy_bytes,
            _witness: witness.clone(),
            _forward_witnesses: [baseline_forward.clone(), candidate_forward.clone()],
        });
        Ok(())
    }

    pub fn verify_prepared_tensor_content(
        &mut self,
        step: &SemanticPreparedStep,
        witness: &SemanticTensorContentWitness,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_content_witness(step, witness)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope");
        let recorded = !build.finished;
        if recorded {
            self.check_prepared_content_stream(step, consumer_stream)?;
        } else if !build.completed
            || !self.steps[&step.token]
                .prepared
                .as_ref()
                .expect("prepared owner")
                .observed
        {
            return Err(publication_input_error(
                "retained content requires an actually completed prepared invocation",
            ));
        }
        let actual = prepare_semantic_tensors(&self.provider, tensors)?;
        let content = &mut self
            .steps
            .get_mut(&step.token)
            .expect("checked fixed step")
            .content[witness.index];
        let start = content.verification_inputs.len();
        content.verification_inputs.extend(actual);
        let actual = &content.verification_inputs[start..];
        if content.tensors.len() != actual.len()
            || content
                .tensors
                .iter()
                .zip(actual)
                .any(|(expected, actual)| !same_tensor_content_owner(expected, actual))
        {
            self.poisoned = true;
            return Err(publication_input_error("content verification requires the exact original tensor owners, layout and interval"));
        }
        if recorded {
            self.record_prepared_tensor_content(step, witness, true)
        } else {
            self.enqueue_content_witness(witness, consumer_stream, true)
        }
    }

    pub fn record_prepared_step_admission(
        &mut self,
        step: &SemanticPreparedStep,
        conditional_handle: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        if conditional_handle == 0
            || !self
                .prepared_segment
                .as_ref()
                .expect("checked build")
                .capturing
        {
            return Err(publication_input_error(
                "step admission requires the actual conditional capture handle",
            ));
        }
        let requested_kind = self
            .prepared_segment
            .as_mut()
            .expect("checked build")
            .enter(step, &self.publication_issuer)?;
        let storage = self.publication.as_ref().expect("prepared publication");
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared lease owner");
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope");
        let previous = build.next.checked_sub(1).map(|index| {
            &self.steps[&build.tokens[index]]
                .prepared
                .as_ref()
                .expect("previous prepared step")
                .result
        });
        let mut recorder = self.domain.new_strict_recorder();
        storage.record(&mut recorder);
        recorder.write(&prepared.reader);
        if let Some(previous) = previous {
            recorder.read(previous);
        }
        let arguments = (
            storage.control.device_ptr_value(),
            prepared.reader.device_ptr_value(),
            requested_kind.code(),
            conditional_handle,
            previous.map_or(0, TrackedCudaSlice::device_ptr_value),
        );
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: actual parent control and unique lease are fixed owners;
            // the graph issues this IF handle and the kernel writes every replay.
            unsafe {
                prepared.admit.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    pub fn record_prepared_step_inputs(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        if self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared owner")
            .inputs_recorded
        {
            return Err(publication_input_error(
                "prepared input producer records exactly once",
            ));
        }
        // The complete original read roster is validated before feedback,
        // codebook, causal, or numerical consumers can read any parent value.
        let keys = self.prepared_range_keys(step)?;
        self.guard_prepared_content(step, &keys, self.stream.cu_stream() as usize as u64)?;
        let owner = &self.steps[&step.token];
        let descriptor = self.descriptor();
        owner
            .inputs
            .as_ref()
            .expect("fixed input owner")
            .enqueue(&self.domain, &mut self.poisoned)?;
        if let Some(custody) = &owner
            .prepared
            .as_ref()
            .expect("prepared owner")
            .replay_custody
        {
            custody.enqueue_parent(
                &self.domain,
                &mut self.poisoned,
                self.publication.as_ref().expect("prepared publication"),
                &owner.prepared.as_ref().expect("prepared owner").reader,
                &self.graph,
            )?;
        }
        owner.feedback[0].enqueue(
            &self.domain,
            &mut self.poisoned,
            &self.graph,
            self.publication.as_ref().expect("prepared publication"),
            &self
                .task
                .as_ref()
                .ok_or(SemanticTransitionError::InvalidTaskBank)?
                .1,
            &owner.prepared.as_ref().expect("prepared lease").reader,
            descriptor,
        )?;
        let selection = if let Some(selected) = owner
            .prepared
            .as_ref()
            .expect("prepared selection owner")
            .training_view
            .as_ref()
        {
            let selected_view = owner
                .inputs
                .as_ref()
                .expect("fixed input owner")
                .views
                .first()
                .expect("two publication input banks")
                .get(&(SemanticStateRole::TrainingView as u64, 0))
                .cloned()
                .ok_or_else(|| {
                    publication_input_error("prepared update has no acquired training-view input")
                })?;
            let coordinates = owner
                .inputs
                .as_ref()
                .expect("fixed input owner")
                .training_coordinates_view()?;
            selected.enqueue_device_selection(selected_view, coordinates)
        } else {
            Ok(())
        };
        if selection.is_err() {
            self.poisoned = true;
            return selection;
        }
        self.steps
            .get_mut(&step.token)
            .expect("checked step")
            .prepared
            .as_mut()
            .expect("prepared owner")
            .inputs_recorded = true;
        Ok(())
    }

    fn record_prepared_step_kind_gate(
        &mut self,
        step: &SemanticPreparedStep,
        expected_kind: SemanticTransitionKind,
        conditional_handle: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        if conditional_handle == 0 {
            return Err(publication_input_error(
                "prepared kind gate requires the actual conditional capture handle",
            ));
        }
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared lease owner");
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&prepared.reader);
        let arguments = (
            prepared.reader.device_ptr_value(),
            expected_kind.code(),
            conditional_handle,
        );
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: the lease and conditional handle belong to this original
            // prepared step and remain live throughout the captured segment.
            unsafe {
                prepared.kind_gate.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    pub fn record_prepared_step_requested_bank_gate(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        conditional_handle: u64,
    ) -> Result<(), SemanticTransitionError> {
        let expected = self.prepared_transition_kind(step)?;
        self.checked_prepared_step(step, true)?;
        if bank > 1 || conditional_handle == 0 {
            return Err(publication_input_error(
                "prepared bank gate requires bank zero or one and the actual conditional capture handle",
            ));
        }
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared lease owner");
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&prepared.reader);
        let arguments = (
            prepared.reader.device_ptr_value(),
            expected.code(),
            bank as u64,
            conditional_handle,
        );
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: the device lease selects exactly one resident input bank;
            // this conditional exposes neither the lease nor its bank to host code.
            unsafe {
                prepared.kind_bank_gate.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    #[cfg(feature = "semantic-policy")]
    pub fn begin_prepared_step_bank_capture(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        let prepared = self
            .steps
            .get_mut(&step.token)
            .expect("checked prepared bank step")
            .prepared
            .as_mut()
            .expect("prepared bank owner");
        let recorded = prepared.transition_recorded;
        let result = prepared
            .model_work
            .as_mut()
            .ok_or_else(|| publication_input_error("prepared bank requires original model work"))
            .and_then(|work| {
                work.begin_capture(bank, recorded)
                    .map_err(publication_input_error)
            });
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    #[cfg(feature = "semantic-policy")]
    /// Record the model seals owned by one prepared branch before its producer
    /// can enqueue model reads into that branch's conditional body.
    pub fn record_prepared_bank_model_content(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared model content bank must be zero or one",
            ));
        }
        let owner = &self.steps[&step.token];
        let prepared = owner
            .prepared
            .as_ref()
            .expect("prepared model content owner");
        if prepared.model_content_recorded & (1 << bank) != 0 {
            return Err(publication_input_error(
                "prepared model content records once per bank branch",
            ));
        }
        let indices = owner
            .content
            .iter()
            .enumerate()
            .filter_map(|(index, content)| match &content.seals {
                TensorContentSeals::Model(seals)
                    if seals
                        .prepared
                        .as_ref()
                        .is_some_and(|source| source.bank == bank) =>
                {
                    Some(index)
                }
                _ => None,
            })
            .collect::<Vec<_>>();
        if indices.is_empty() {
            return Err(publication_input_error(
                "prepared branch has no original admitted model content",
            ));
        }
        for index in indices {
            let TensorContentSeals::Model(seals) = &self.steps[&step.token].content[index].seals
            else {
                return Err(SemanticTransitionError::ObservationMismatch);
            };
            seals.snapshot_prepared(&self.domain, &mut self.poisoned)?;
            let witness = SemanticTensorContentWitness {
                issuer: Arc::clone(&self.publication_issuer),
                reader_token: step.token,
                index,
                _witness: Arc::clone(&self.steps[&step.token].content_witnesses),
            };
            self.record_prepared_tensor_content(step, &witness, true)?;
        }
        self.steps
            .get_mut(&step.token)
            .expect("prepared model content owner")
            .prepared
            .as_mut()
            .expect("prepared model content storage")
            .model_content_recorded |= 1 << bank;
        Ok(())
    }

    pub fn record_prepared_step_drain_gate(
        &mut self,
        step: &SemanticPreparedStep,
        conditional_handle: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.record_prepared_step_kind_gate(step, SemanticTransitionKind::Drain, conditional_handle)
    }

    pub fn record_prepared_step_active_gate(
        &mut self,
        step: &SemanticPreparedStep,
        conditional_handle: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        if conditional_handle == 0 {
            return Err(publication_input_error(
                "prepared release gate requires the actual conditional capture handle",
            ));
        }
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared lease owner");
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&prepared.reader);
        let arguments = (prepared.reader.device_ptr_value(), conditional_handle);
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: this device predicate exposes no lease value to the host;
            // it only releases an actually acquired original step.
            unsafe {
                prepared.active_gate.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })
    }

    pub fn guard_prepared_content(
        &mut self,
        step: &SemanticPreparedStep,
        keys: &[(SemanticStateRole, u64)],
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        if dlpack_consumer_stream(consumer_stream)? != self.stream.cu_stream() || keys.is_empty() {
            return Err(publication_input_error(
                "prepared content guard requires original ranges on the native capture stream",
            ));
        }
        let storage = self.publication.as_ref().expect("prepared publication");
        let owner = &self.steps[&step.token];
        let prepared = owner.prepared.as_ref().expect("prepared lease");
        let mut distinct = BTreeSet::new();
        for &(role, index) in keys {
            if !distinct.insert((role as u64, index))
                || !storage.bank_templates[0]
                    .iter()
                    .any(|range| (range.role, range.index) == (role as u64, index))
            {
                return Err(publication_input_error(
                    "prepared guard names duplicate or undeclared original ranges",
                ));
            }
            let layout = if is_tensor_role(role as u64) {
                *storage
                    .layouts
                    .get(&(role as u64, index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?
            } else {
                SemanticTensorLayout::default()
            };
            storage.enqueue_content_guard(
                &self.domain,
                &mut self.poisoned,
                prepared.reader.view(),
                &prepared.content_guard,
                role as u64,
                index,
                layout,
            )?;
        }
        if prepared.inputs_recorded {
            owner
                .inputs
                .as_ref()
                .expect("fixed input owner")
                .verify(&self.domain, &mut self.poisoned)?;
            owner.feedback[0].content.enqueue(
                &self.domain,
                &mut self.poisoned,
                &prepared.witness,
                true,
            )?;
        }
        Ok(())
    }

    pub fn record_prepared_step_release(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, true)?;
        let storage = self.publication.as_ref().expect("prepared publication");
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared lease");
        if prepared.transition_recorded != PREPARED_TRANSITION_BANKS || !prepared.drain_recorded {
            return Err(publication_input_error(
                "release must follow this prepared step's complete native transition and drain branches",
            ));
        }
        let mut recorder = self.domain.new_strict_recorder();
        storage.record(&mut recorder);
        recorder.read_write(&prepared.reader);
        recorder.read(
            &self.steps[&step.token]
                .inputs
                .as_ref()
                .expect("fixed input owner")
                .header,
        );
        recorder.write(&prepared.result);
        if let Some(origin) = &prepared.training_origin {
            recorder.write(origin);
        }
        let arguments = (
            storage.control.device_ptr_value(),
            prepared.reader.device_ptr_value(),
        );
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: save the actual successor or refusal while the exact
            // acquired parent and current bank still belong to this step.
            unsafe {
                prepared.result_kernel.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (
                        storage.control.device_ptr_value(),
                        prepared.reader.device_ptr_value(),
                        prepared.result.device_ptr_value(),
                        self.steps[&step.token]
                            .inputs
                            .as_ref()
                            .expect("fixed input owner")
                            .header
                            .device_ptr_value(),
                        prepared
                            .training_origin
                            .as_ref()
                            .map_or(0, |origin| *origin.device_ptr()),
                    ),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))?;
            // SAFETY: release follows this step's body in the actual IF graph;
            // the native lease remains owned for all later retained witnesses.
            unsafe {
                prepared.release.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        self.prepared_segment
            .as_mut()
            .expect("checked build")
            .leave(step, &self.publication_issuer)
    }

    pub fn finish_prepared_segment(
        &mut self,
        executable: &mut Option<SemanticPreparedExecutable>,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        let build = self
            .prepared_segment
            .as_mut()
            .ok_or(SemanticTransitionError::NotBound)?;
        if self.captured.is_some()
            || executable
                .as_ref()
                .is_none_or(|executable| !Arc::ptr_eq(&executable.scope, &build.scope))
        {
            return Err(publication_input_error(
                "executable differs from the original native segment construction",
            ));
        }
        #[cfg(feature = "semantic-policy")]
        for token in &build.tokens {
            let prepared = self.steps[token]
                .prepared
                .as_ref()
                .expect("original prepared owner");
            if prepared
                .training_view
                .as_ref()
                .is_some_and(|view| view.actor_group_member_count() > 1)
                && prepared.group_critic_recorded != 0b11
            {
                return Err(publication_input_error(
                    "multi-member Update requires the complete frozen group critic in both banks",
                ));
            }
            if (0..2).any(|bank| {
                prepared.group_imported_vjp_members[bank] != prepared.group_gradient_members[bank]
            }) {
                return Err(publication_input_error(
                    "every imported group VJP requires its original physical gradient delivery in the same bank",
                ));
            }
        }
        build.finish()?;
        // Upload only immutable first-recording geometry, after capture and
        // before any graph launch. The original step retains this allocation.
        for token in &build.tokens {
            let prepared = self.steps[token]
                .prepared
                .as_ref()
                .expect("original prepared owner");
            let work = prepared.model_work.as_ref().ok_or_else(|| {
                publication_input_error("prepared body has no frozen original model work")
            })?;
            if work.recording.frozen_bound().is_none() {
                return Err(publication_input_error(
                    "original model work was not frozen by its transition",
                ));
            }
            if let Some(custody) = &prepared.replay_custody {
                work.recording
                    .frozen_bound()
                    .expect("checked frozen original work")
                    .checked_add(custody.copy_work_bound()?)
                    .ok_or(SemanticTransitionError::GenerationExhausted)?;
            }
            let mut destination = work.device.view().slice(..work.recording.events().len());
            self.provider
                .htod_launch_metadata_sync_copy_into(work.recording.events(), &mut destination)
                .map_err(|error| runtime_error("original model work cold upload", error))?;
            for branch in &prepared.branches {
                if let Some(update) = &branch.model_update {
                    let output = update.output.as_ref().ok_or_else(|| {
                        publication_input_error(
                            "prepared update has no branch-owned model output binding",
                        )
                    })?;
                    let mut destination = update.bindings.view();
                    self.provider
                        .htod_launch_metadata_sync_copy_into(&output.values, &mut destination)
                        .map_err(|error| {
                            runtime_error("model update binding cold upload", error)
                        })?;
                    let mut forward_seals = update.forward_seals.view();
                    self.provider
                        .htod_launch_metadata_sync_copy_into(
                            &output.forward_seal_values,
                            &mut forward_seals,
                        )
                        .map_err(|error| runtime_error("model forward seal cold upload", error))?;
                }
            }
        }
        executable
            .as_ref()
            .expect("checked authentic executable")
            .graph
            .upload_cold(&self.stream)
            .map_err(|error| runtime_error("prepared graph cold upload", error))?;
        // Failure leaves the actual graph in the caller's owner. No graph
        // destructor or driver completion can run under its Session mutex.
        self.captured = Some(
            executable
                .take()
                .expect("checked authentic executable")
                .graph,
        );
        Ok(())
    }

    /// Detach the completed executable so the caller can destroy it outside its
    /// Session mutex. The actual allocation resources remain Session-owned until
    /// every original prepared step and its final consumers have retired.
    pub fn take_prepared_executable_for_retirement(
        &mut self,
    ) -> Result<Option<CapturedCudaGraph>, SemanticTransitionError> {
        if self
            .prepared_segment
            .as_ref()
            .is_none_or(|build| !build.completed)
        {
            return Err(publication_input_error(
                "prepared executable retirement requires known actual completion",
            ));
        }
        Ok(self.captured.take())
    }

    /// Return the original pool/model owners only after all joined step owners
    /// and their imported aliases are gone. Drop the returned owners unlocked.
    pub fn take_prepared_resources_for_retirement(
        &mut self,
    ) -> Result<Vec<Arc<dyn Send + Sync>>, SemanticTransitionError> {
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        if !build.completed
            || self.captured.is_some()
            || build
                .tokens
                .iter()
                .any(|token| self.steps.contains_key(token))
        {
            return Err(publication_input_error(
                "original prepared resources still own an executable or retained step",
            ));
        }
        let resources = std::mem::take(&mut self.prepared_resources);
        self.prepared_segment = None;
        Ok(resources)
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_segment_recorder(&self) -> Result<LaunchRecorder, SemanticTransitionError> {
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        // Shared arena, scratch, immutable catalogue and the actual feedback
        // descriptor owners remain part of this same strict recorded launch.
        let mut recorder = self.kernel_recorder();
        self.publication
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?
            .record(&mut recorder);
        for token in &build.tokens {
            let owner = self
                .steps
                .get(token)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let prepared = owner
                .prepared
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            recorder.read_write(&prepared.reader);
            recorder.write(&prepared.result);
            if let Some(custody) = &prepared.replay_custody {
                custody.record(&mut recorder);
            }
            if let Some(work) = &prepared.model_work {
                recorder.read(&work.device);
                recorder.read_write(&work.actual);
            }
            if let Some(digests) = &prepared.digests {
                recorder.read_write(digests.as_ref());
            }
            let inputs = owner
                .inputs
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            for bindings in &inputs.bindings {
                recorder.read(bindings);
            }
            recorder.write(&inputs.header);
            recorder.write(&inputs.source);
            recorder.write(&inputs.ranges);
            recorder.write(&inputs.metadata_digests);
            for allocation in &inputs.private {
                recorder.write(allocation);
            }
            for bank in &inputs.views {
                for view in bank.values() {
                    recorder.read_write(view);
                }
            }
            for feedback in &owner.feedback {
                recorder.write(&feedback.status);
            }
            for content in owner
                .content
                .iter()
                .chain(owner.feedback.iter().map(|feedback| &feedback.content))
            {
                for tensor in content.tensors.iter().chain(&content.verification_inputs) {
                    if let Some(source) = &tensor.source {
                        recorder.read_write(source);
                    }
                }
                match &content.seals {
                    TensorContentSeals::Captured(digests) => {
                        for digest in digests {
                            if let CapturedTensorDigest::Tensor { cells, .. } = digest {
                                recorder.read_write(cells.as_ref());
                            }
                        }
                    }
                    TensorContentSeals::Model(model) => {
                        recorder.read_write(&model.ranges);
                        recorder.read_write(&model.contract);
                        if let Some(source) = &model.prepared {
                            recorder.read(&source.roster);
                            recorder.read(&source.reader);
                        }
                    }
                }
            }
            for branch in &prepared.branches {
                if let Some(continuation) = &branch.continuation {
                    continuation.text_binding.record(&mut recorder);
                    for tensor in &continuation.sources {
                        if let Some(source) = &tensor.source {
                            recorder.read(source);
                        }
                    }
                }
                if let Some(update) = &branch.model_update {
                    update.record(&mut recorder);
                }
                #[cfg(feature = "semantic-policy")]
                {
                    recorder.write(&branch.state);
                    recorder.write(
                        branch
                            .support
                            .as_ref()
                            .ok_or(SemanticTransitionError::ObservationMismatch)?,
                    );
                    recorder.write(
                        branch
                            .receipts
                            .as_ref()
                            .ok_or(SemanticTransitionError::ObservationMismatch)?,
                    );
                    if let Some(policy) = &branch.policy {
                        policy.numerical.record(&mut recorder);
                        for buffer in [
                            &policy.parameters,
                            &policy.hidden,
                            &policy.scores,
                            &policy.retained_scores,
                            &policy.recurrent,
                            &policy.text_logits,
                        ] {
                            recorder.read_write(buffer);
                        }
                        policy.text_binding.record(&mut recorder);
                    } else {
                        recorder.read(
                            &branch
                                .policy_buffers
                                .as_ref()
                                .ok_or(SemanticTransitionError::NotBound)?
                                .text_logits,
                        );
                    }
                    for tensor in &branch.policy_sources {
                        if let Some(source) = &tensor.source {
                            recorder.read(source);
                        }
                    }
                }
            }
        }
        Ok(recorder)
    }

    /// Reserve exactly one native prefill stage for the imported task. The
    /// expected tokens come from its admitted source mapping, not a model-side
    /// copy. This stage owns the device comparison input before any model call.
    pub fn begin_initial_prefill(
        &mut self,
        layout: SemanticInitialSourceLayout,
        model_generation: u64,
    ) -> Result<SemanticInitialPrefillLease, SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some() || self.initial_prefill.is_some() {
            return Err(publication_input_error(
                "initial prefill requires one unpublished imported task",
            ));
        }
        let task_identity = self
            .task_evaluation_identity()
            .ok_or(SemanticTransitionError::NotBound)?;
        if model_generation == 0 || layout.prefill_tokens.is_empty() {
            return Err(publication_input_error(
                "initial prefill requires a model generation and nonempty committed prefix",
            ));
        }
        if layout.prefill_tokens.len() != layout.prefix.len()
            || layout.prefix.iter().enumerate().any(|(position, row)| {
                row.token != layout.prefill_tokens[position]
                    || row.logical_position != position as u64
                    || row.kind != 1
                    || row.provenance != 1
                    || row.valid != 1
                    || row.committed != 1
            })
        {
            return Err(publication_input_error(
                "initial prefill layout differs from the admitted ordered prefix",
            ));
        }
        let expected_tokens = allocate_publication(&self.provider, layout.prefill_tokens.len())?;
        let scope = Arc::new(());
        self.initial_prefill = Some(InitialPrefillStage {
            scope: Arc::clone(&scope),
            task_identity,
            task_epoch: self.task_epoch,
            model_generation,
            layout,
            expected_tokens,
            input: None,
            model_content: None,
            output_content: None,
            captured_content: Vec::new(),
            consumer_stream: None,
        });
        let stage = self
            .initial_prefill
            .as_mut()
            .expect("stage installed before upload");
        if let Err(error) = self
            .provider
            .htod_sync_copy_into_tracked(&stage.layout.prefill_tokens, &mut stage.expected_tokens)
        {
            self.poisoned = true;
            return Err(runtime_error("initial prefill token upload", error));
        }
        Ok(SemanticInitialPrefillLease {
            issuer: Arc::clone(&self.publication_issuer),
            scope,
        })
    }

    /// Compare the actual I64 tensor at the model's pre-hook against the
    /// admitted prefix on device. The stream edge completes before the model
    /// continues, and the original DLPack owner remains in this stage.
    pub fn record_initial_prefill_input(
        &mut self,
        lease: &SemanticInitialPrefillLease,
        input: SemanticTensorInput,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        dlpack_consumer_stream(consumer_stream)?;
        let stage = self
            .initial_prefill
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        if !Arc::ptr_eq(&self.publication_issuer, &lease.issuer)
            || !Arc::ptr_eq(&stage.scope, &lease.scope)
            || self.publication.is_some()
            || stage.task_epoch != self.task_epoch
            || self.task_evaluation_identity() != Some(stage.task_identity)
            || stage.model_content.is_none()
            || stage.consumer_stream != Some(consumer_stream)
            || stage.input.is_some()
        {
            return Err(publication_input_error(
                "initial prefill input belongs to another or already-used task stage",
            ));
        }
        validate_initial_prefill_input_layout(
            &input.layout,
            stage.layout.prefill_tokens.len() as u64,
        )?;
        if input.logical_begin != 0 || input.logical_end != stage.layout.prefill_tokens.len() as u64
        {
            return Err(publication_input_error(
                "initial prefill input interval differs from the admitted prefix",
            ));
        }
        let mut prepared = prepare_semantic_tensors(&self.provider, vec![input])?;
        let input = prepared.pop().expect("one checked prefill input");
        let actual_ptr = input.data;
        self.initial_prefill.as_mut().expect("checked stage").input = Some(input);
        self.initial_prefill
            .as_mut()
            .expect("checked stage")
            .consumer_stream = Some(consumer_stream);
        let result = (|| {
            self.order_tensor_producer_inputs(consumer_stream)?;
            let stage = self
                .initial_prefill
                .as_ref()
                .expect("retained prefill stage");
            let execute = self
                .provider
                .device()
                .inner()
                .get_func(
                    "xlog_semantic_transition",
                    "semantic_initial_prefill_input_guard",
                )
                .ok_or_else(|| {
                    runtime_error("kernel lookup", "initial prefill input guard unavailable")
                })?;
            let mut recorder = self.domain.new_strict_recorder();
            recorder.read(&stage.expected_tokens);
            recorder.read(
                stage
                    .input
                    .as_ref()
                    .expect("retained prefill input")
                    .source
                    .as_ref()
                    .ok_or_else(|| {
                        publication_input_error(
                            "initial prefill input has no original device storage",
                        )
                    })?,
            );
            let arguments = (
                stage.expected_tokens.device_ptr_value(),
                actual_ptr,
                stage.layout.prefill_tokens.len() as u64,
            );
            enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
                // SAFETY: both original producer and expected-token allocations
                // are retained by this stage; layout and stream were checked.
                unsafe {
                    execute.launch_in(
                        enqueue,
                        LaunchConfig {
                            grid_dim: (1, 1, 1),
                            block_dim: (1, 1, 1),
                            shared_mem_bytes: 0,
                        },
                        arguments,
                    )
                }
                .map_err(|error| XlogError::Kernel(error.to_string()))
            })?;
            self.stream
                .synchronize()
                .map_err(|error| runtime_error("initial prefill input verification", error))?;
            self.order_content_consumers(consumer_stream)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Seal the original model roster before its prefill forward. The caller
    /// supplies model tensors followed by their complete original backing
    /// allocations, exactly as it will supply them to parent binding.
    pub fn bind_initial_prefill_model_content(
        &mut self,
        lease: &SemanticInitialPrefillLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticInitialPrefillContentWitness, SemanticTransitionError> {
        self.capture_initial_prefill_roster(
            lease,
            tensors,
            consumer_stream,
            InitialPrefillCaptureKind::Model,
        )?
        .ok_or(SemanticTransitionError::ObservationMismatch)
    }

    /// Capture original pre-call, transient or saved tensors after the model
    /// roster is sealed, before any dependent read may change their bytes.
    /// Pre-call capture does not replace the actual input pre-hook.
    pub fn capture_initial_prefill_tensor_content(
        &mut self,
        lease: &SemanticInitialPrefillLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticInitialPrefillContentWitness, SemanticTransitionError> {
        self.capture_initial_prefill_roster(
            lease,
            tensors,
            consumer_stream,
            InitialPrefillCaptureKind::Captured,
        )?
        .ok_or(SemanticTransitionError::ObservationMismatch)
    }

    /// Seal the original model outputs at the post-detach wrapper boundary.
    /// Every prefill cache/state tensor later supplied to parent binding must
    /// be this exact allocation, layout and logical interval.
    pub fn record_initial_prefill_outputs(
        &mut self,
        lease: &SemanticInitialPrefillLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.capture_initial_prefill_roster(
            lease,
            tensors,
            consumer_stream,
            InitialPrefillCaptureKind::Outputs,
        )?;
        Ok(())
    }

    fn capture_initial_prefill_roster(
        &mut self,
        lease: &SemanticInitialPrefillLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
        kind: InitialPrefillCaptureKind,
    ) -> Result<Option<SemanticInitialPrefillContentWitness>, SemanticTransitionError> {
        self.ensure_quiescent()?;
        dlpack_consumer_stream(consumer_stream)?;
        let stage = self
            .initial_prefill
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        if !Arc::ptr_eq(&self.publication_issuer, &lease.issuer)
            || !Arc::ptr_eq(&stage.scope, &lease.scope)
            || self.publication.is_some()
            || stage.task_epoch != self.task_epoch
            || self.task_evaluation_identity() != Some(stage.task_identity)
            || stage
                .consumer_stream
                .is_some_and(|stream| stream != consumer_stream)
            || match kind {
                InitialPrefillCaptureKind::Model => {
                    stage.model_content.is_some() || stage.input.is_some()
                }
                InitialPrefillCaptureKind::Outputs => {
                    stage.model_content.is_none()
                        || stage.input.is_none()
                        || stage.output_content.is_some()
                }
                InitialPrefillCaptureKind::Captured => {
                    stage.model_content.is_none() || stage.output_content.is_some()
                }
            }
        {
            return Err(publication_input_error(
                "initial prefill roster belongs to another stage, stream or forward order",
            ));
        }
        if tensors.is_empty()
            || tensors.iter().any(|tensor| match kind {
                InitialPrefillCaptureKind::Model => !matches!(tensor.layout.role, 0 | 18..=25),
                InitialPrefillCaptureKind::Outputs => !matches!(tensor.layout.role, 4..=13),
                InitialPrefillCaptureKind::Captured => false,
            })
        {
            return Err(publication_input_error(
                "initial prefill model or output roster has missing or foreign tensor roles",
            ));
        }
        let prepared = prepare_semantic_tensors(&self.provider, tensors)?;
        let stage = self
            .initial_prefill
            .as_mut()
            .expect("checked prefill stage");
        let content = TensorContentBuffers {
            tensors: prepared,
            seals: TensorContentSeals::Captured(Vec::new()),
            verification_inputs: Vec::new(),
        };
        let slot = match kind {
            InitialPrefillCaptureKind::Model => {
                stage.model_content = Some(content);
                Some(InitialPrefillContentSlot::Model)
            }
            InitialPrefillCaptureKind::Outputs => {
                stage.output_content = Some(content);
                None
            }
            InitialPrefillCaptureKind::Captured => {
                let index = stage.captured_content.len();
                stage.captured_content.push(content);
                Some(InitialPrefillContentSlot::Captured(index))
            }
        };
        stage.consumer_stream = Some(consumer_stream);
        let witness = slot.map(|slot| SemanticInitialPrefillContentWitness {
            issuer: Arc::clone(&self.publication_issuer),
            scope: Arc::clone(&stage.scope),
            task_identity: stage.task_identity,
            task_epoch: stage.task_epoch,
            model_generation: stage.model_generation,
            slot,
        });
        let result = (|| {
            self.order_tensor_producer_inputs(consumer_stream)?;
            let stage = self
                .initial_prefill
                .as_ref()
                .expect("retained prefill stage");
            let content = match kind {
                InitialPrefillCaptureKind::Model => stage
                    .model_content
                    .as_ref()
                    .expect("retained model content"),
                InitialPrefillCaptureKind::Outputs => stage
                    .output_content
                    .as_ref()
                    .expect("retained output content"),
                InitialPrefillCaptureKind::Captured => stage
                    .captured_content
                    .last()
                    .expect("retained transient content"),
            };
            // Model views precede their backing allocations. Role-zero indices
            // name allocation ordinals, unlike private capture positions.
            let private_prefix = if matches!(kind, InitialPrefillCaptureKind::Model) {
                content
                    .tensors
                    .iter()
                    .filter(|tensor| tensor.layout.role != 0)
                    .count()
            } else {
                0
            };
            validate_content_coordinates_after(
                content
                    .tensors
                    .iter()
                    .map(|tensor| (tensor.layout.role, tensor.layout.index)),
                private_prefix,
            )?;
            let digests = content
                .tensors
                .iter()
                .map(|tensor| {
                    tensor_content_range(
                        &tensor.layout,
                        tensor.logical_begin,
                        tensor.logical_end,
                        tensor.source.as_ref().map_or(0, DeviceMemoryView::len),
                    )?;
                    Ok(CapturedTensorDigest::Tensor {
                        cells: Arc::new(allocate_publication(&self.provider, 4)?),
                        offset: 0,
                        producer_sealed: false,
                    })
                })
                .collect::<Result<Vec<_>, SemanticTransitionError>>()?;
            let stage = self
                .initial_prefill
                .as_mut()
                .expect("retained prefill stage");
            let content = match kind {
                InitialPrefillCaptureKind::Model => stage
                    .model_content
                    .as_mut()
                    .expect("retained model content"),
                InitialPrefillCaptureKind::Outputs => stage
                    .output_content
                    .as_mut()
                    .expect("retained output content"),
                InitialPrefillCaptureKind::Captured => stage
                    .captured_content
                    .last_mut()
                    .expect("retained transient content"),
            };
            content.seals = TensorContentSeals::Captured(digests);
            let stage = self
                .initial_prefill
                .as_ref()
                .expect("retained prefill stage");
            let content = match kind {
                InitialPrefillCaptureKind::Model => stage
                    .model_content
                    .as_ref()
                    .expect("retained model content"),
                InitialPrefillCaptureKind::Outputs => stage
                    .output_content
                    .as_ref()
                    .expect("retained output content"),
                InitialPrefillCaptureKind::Captured => stage
                    .captured_content
                    .last()
                    .expect("retained transient content"),
            };
            let execute = self
                .provider
                .device()
                .inner()
                .get_func(
                    "xlog_semantic_transition",
                    "semantic_tensor_content_witness",
                )
                .ok_or_else(|| {
                    runtime_error("kernel lookup", "tensor content witness unavailable")
                })?;
            content.enqueue(&self.domain, &mut self.poisoned, &execute, false)?;
            self.order_content_consumers(consumer_stream)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result.map(|()| witness)
    }

    /// Check the same original prefill seal before a dependent model or saved
    /// tensor read, including after the parent has consumed the one-use stage.
    pub fn verify_initial_prefill_tensor_content(
        &mut self,
        lease: &SemanticInitialPrefillLease,
        witness: &SemanticInitialPrefillContentWitness,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let mut handoff = RetainedTensorAdmission {
            inputs: Some(tensors),
            stream: Arc::clone(self.provider.device().inner().stream()),
            ready: false,
        };
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        dlpack_consumer_stream(consumer_stream)?;
        let (scope, task_identity, task_epoch, model_generation, captured_count) =
            if let Some(stage) = self.initial_prefill.as_ref() {
                (
                    &stage.scope,
                    stage.task_identity,
                    stage.task_epoch,
                    stage.model_generation,
                    stage.captured_content.len(),
                )
            } else if let Some(retained) = self.retained_initial_prefill.as_ref() {
                (
                    &retained.scope,
                    retained.task_identity,
                    retained.task_epoch,
                    retained.model_generation,
                    retained.captured.len(),
                )
            } else {
                return Err(SemanticTransitionError::NotBound);
            };
        if !Arc::ptr_eq(&self.publication_issuer, &lease.issuer)
            || !Arc::ptr_eq(scope, &lease.scope)
            || self.task_epoch != task_epoch
            || self.task_evaluation_identity() != Some(task_identity)
            || !witness.matches(
                &self.publication_issuer,
                scope,
                task_identity,
                task_epoch,
                model_generation,
                captured_count,
            )
        {
            return Err(publication_input_error(
                "initial prefill content witness belongs to another task, stream or stage",
            ));
        }
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("prefill content stream admission", error))?;
        let prepared = prepare_semantic_tensors(
            &self.provider,
            handoff
                .inputs
                .take()
                .expect("retained original prefill verification inputs"),
        )?;
        let content = if let Some(stage) = self.initial_prefill.as_mut() {
            match witness.slot {
                InitialPrefillContentSlot::Model => stage.model_content.as_mut(),
                InitialPrefillContentSlot::Captured(index) => stage.captured_content.get_mut(index),
            }
        } else {
            self.retained_initial_prefill
                .as_mut()
                .and_then(|retained| match witness.slot {
                    InitialPrefillContentSlot::Model => Some(&mut retained.model),
                    InitialPrefillContentSlot::Captured(index) => retained.captured.get_mut(index),
                })
        }
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let offset = content.verification_inputs.len();
        content.verification_inputs.extend(prepared);
        let actual = &content.verification_inputs[offset..];
        if actual.len() != content.tensors.len()
            || content
                .tensors
                .iter()
                .zip(actual)
                .any(|(expected, actual)| !same_tensor_content_owner(expected, actual))
        {
            return Err(publication_input_error(
                "prefill content verification requires the original storage, layout and interval",
            ));
        }
        let result = (|| {
            self.order_tensor_producer_inputs(consumer_stream)?;
            let content = if let Some(stage) = self.initial_prefill.as_ref() {
                match witness.slot {
                    InitialPrefillContentSlot::Model => stage.model_content.as_ref(),
                    InitialPrefillContentSlot::Captured(index) => stage.captured_content.get(index),
                }
            } else {
                self.retained_initial_prefill
                    .as_ref()
                    .and_then(|retained| match witness.slot {
                        InitialPrefillContentSlot::Model => Some(&retained.model),
                        InitialPrefillContentSlot::Captured(index) => retained.captured.get(index),
                    })
            }
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let execute = self
                .provider
                .device()
                .inner()
                .get_func(
                    "xlog_semantic_transition",
                    "semantic_tensor_content_witness",
                )
                .ok_or_else(|| {
                    runtime_error("kernel lookup", "tensor content witness unavailable")
                })?;
            content.enqueue(&self.domain, &mut self.poisoned, &execute, true)?;
            self.order_content_consumers(consumer_stream)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    fn verify_initial_prefill_parent(
        &mut self,
        parent: &SemanticParentBinding,
        tensors: &[PreparedSemanticTensor],
        allocations: &[PreparedSemanticTensor],
    ) -> Result<(), SemanticTransitionError> {
        if parent.prefix.is_empty() {
            if self.initial_prefill.is_some() {
                return Err(publication_input_error(
                    "an initial prefill stage cannot be bound to an empty prefix",
                ));
            }
            return Ok(());
        }
        let stage = self.initial_prefill.as_ref().ok_or_else(|| {
            publication_input_error(
                "nonempty initial prefix requires its original model prefill stage",
            )
        })?;
        let model = stage.model_content.as_ref().ok_or_else(|| {
            publication_input_error("initial prefill has no original model-content witness")
        })?;
        let outputs = stage.output_content.as_ref().ok_or_else(|| {
            publication_input_error("initial prefill has no original model-output witness")
        })?;
        let model_inputs = tensors
            .iter()
            .filter(|tensor| matches!(tensor.layout.role, 18..=25))
            .chain(allocations);
        let output_inputs = tensors
            .iter()
            .filter(|tensor| matches!(tensor.layout.role, 4..=13));
        if self.publication.is_some()
            || stage.task_epoch != self.task_epoch
            || self.task_evaluation_identity() != Some(stage.task_identity)
            || stage.task_epoch != parent.authority_generation
            || stage.model_generation != parent.model_generation
            || stage.input.is_none()
            || stage.consumer_stream.is_none()
            || stage.layout.ring_head != parent.ring_head
            || !same_initial_source_rows(&stage.layout.source, &parent.source)
            || !same_initial_source_rows(&stage.layout.prefix, &parent.prefix)
            || parent.provenance_records != stage.layout.provenance_records
            || parent
                .records
                .iter()
                .filter(|record| record.role == SemanticStateRole::TokenProvenanceRecords)
                .count()
                != 1
            || !parent.records.iter().any(|record| {
                record.role == SemanticStateRole::TokenProvenanceRecords
                    && record.index == 0
                    && record.bytes == stage.layout.provenance_bytes
                    && record.capacity_bytes == stage.layout.provenance_capacity_bytes
            })
            || model.tensors.len() != model_inputs.clone().count()
            || !model
                .tensors
                .iter()
                .zip(model_inputs)
                .all(|(expected, actual)| same_tensor_content_owner(expected, actual))
            || outputs.tensors.len() != output_inputs.clone().count()
            || !outputs
                .tensors
                .iter()
                .zip(output_inputs)
                .all(|(expected, actual)| same_tensor_content_owner(expected, actual))
        {
            return Err(publication_input_error(
                "initial parent changed its admitted source, model or original prefill outputs",
            ));
        }
        let stream = stage.consumer_stream.expect("checked prefill stream");
        let result = (|| {
            self.order_tensor_producer_inputs(stream)?;
            let stage = self
                .initial_prefill
                .as_ref()
                .expect("retained prefill stage");
            let execute = self
                .provider
                .device()
                .inner()
                .get_func(
                    "xlog_semantic_transition",
                    "semantic_tensor_content_witness",
                )
                .ok_or_else(|| {
                    runtime_error("kernel lookup", "tensor content witness unavailable")
                })?;
            stage
                .model_content
                .as_ref()
                .expect("checked model content")
                .enqueue(&self.domain, &mut self.poisoned, &execute, true)?;
            stage
                .output_content
                .as_ref()
                .expect("checked output content")
                .enqueue(&self.domain, &mut self.poisoned, &execute, true)?;
            self.order_content_consumers(stream)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Snapshot every supplied cold owner into fixed publication storage, then
    /// initialize and seal bank zero through the actual native command.
    pub fn bind_parent(
        &mut self,
        mut parent: SemanticParentBinding,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        // The handoff guard owns all managed inputs before any later validation
        // can return. Failed cold admission cannot drop an unfinished producer.
        let tensor_count = parent.tensors.len();
        let mut producers = std::mem::take(&mut parent.tensors);
        producers.append(&mut parent.model_memory.allocations);
        let producers = complete_tensor_handoff(&self.provider, producers)?;
        let mut tensors = prepare_semantic_tensors(&self.provider, producers)?;
        let allocations = tensors.split_off(tensor_count);
        let model_memory = prepare_model_memory(
            &allocations,
            std::mem::take(&mut parent.model_memory.storages),
            std::mem::take(&mut parent.model_memory.views),
            &tensors,
        )?;
        self.verify_initial_prefill_parent(&parent, &tensors, &allocations)?;
        self.ensure_rebindable_with_prefill()?;
        if self.publication.is_some() {
            return Err(publication_input_error(
                "this Session already owns a canonical publication instance",
            ));
        }
        let task_identity = self
            .task_evaluation_identity()
            .ok_or(SemanticTransitionError::NotBound)?;
        #[cfg(feature = "semantic-policy")]
        let task_content = self
            .task
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?
            .0
            .content_identity();
        if parent.authority_generation != self.task_epoch {
            return Err(publication_input_error(
                "parent authority generation differs from the retained task import",
            ));
        }
        if parent.recovered_instance.is_some()
            || parent.records.iter().any(|record| {
                matches!(
                    record.role,
                    SemanticStateRole::IntentEntries
                        | SemanticStateRole::IntentPayload
                        | SemanticStateRole::Acknowledgements
                )
            })
        {
            return Err(publication_input_error("fresh parent initialization cannot replace recovered history or accept private intent records"));
        }
        parent.records.extend(initial_intent_records(
            &parent.intent_effect,
            parent.intent_entry_capacity,
            parent.intent_payload_capacity_bytes,
            parent.final_intent_payload_bytes,
        )?);
        parent.records.push(initial_acknowledgement_record(
            parent.intent_entry_capacity,
            parent.acknowledgement_payload_capacity_bytes,
            parent.intent_payload_capacity_bytes,
            parent.intent_effect.len(),
        )?);
        validate_parent_records(&parent, &tensors)?;
        let mut layouts = BTreeMap::new();
        let mut plans = Vec::new();
        for tensor in tensors {
            let layout = if matches!(tensor.layout.role, 18..=25) {
                tensor.layout
            } else if matches!(tensor.layout.role, 4 | 5) {
                prefix_capacity_layout(tensor.layout, parent.prefix_capacity)?
            } else {
                canonical_tensor_layout(tensor.layout)?
            };
            let bytes = tensor_layout_bytes(&layout)?;
            if bytes == 0 && !empty_model_tensor_layout(&layout) {
                return Err(publication_input_error(
                    "non-active tensor destination has no owned extent",
                ));
            }
            layouts.insert((layout.role, layout.index), layout);
            let capacity = if matches!(layout.role, 18..=25) {
                let (allocation, offset) = model_memory.location(layout.role, layout.index)?;
                model_memory.allocation_bytes[allocation] as usize - offset
            } else {
                bytes
            };
            plans.push(PublicationAllocationPlan {
                role: layout.role,
                index: layout.index,
                capacity,
                length: bytes,
                logical_begin: tensor.logical_begin,
                logical_end: tensor.logical_end,
                payload: if matches!(layout.role, 18..=25) {
                    PublicationPayload::Uncomputed
                } else {
                    PublicationPayload::Tensor(tensor)
                },
            });
        }
        for layout in &parent.active_layouts {
            let layout = canonical_tensor_layout(*layout)?;
            let bytes = tensor_layout_bytes(&layout)?;
            layouts.insert((layout.role, layout.index), layout);
            plans.push(PublicationAllocationPlan {
                role: layout.role,
                index: layout.index,
                capacity: bytes,
                length: 0,
                logical_begin: 0,
                logical_end: 0,
                payload: PublicationPayload::Uncomputed,
            });
        }
        for record in &parent.records {
            plans.push(PublicationAllocationPlan {
                role: record.role as u64,
                index: record.index,
                capacity: record.capacity_bytes,
                length: record.bytes.len(),
                logical_begin: 0,
                logical_end: if record.role == SemanticStateRole::TokenProvenanceRecords {
                    parent.provenance_records
                } else {
                    0
                },
                payload: PublicationPayload::Metadata(record.bytes.clone()),
            });
        }
        let statements = self.feedback_statement_bytes()?.map(<[u8]>::to_vec);
        let layout_rows: Vec<_> = layouts.values().copied().collect();
        let prefix_capacity = usize::try_from(parent.prefix_capacity)
            .ok()
            .and_then(|n| n.checked_mul(size_of::<SemanticTextSlot>()))
            .ok_or_else(|| publication_input_error("prefix source capacity overflow"))?;
        let feedback_capacity = usize::try_from(parent.feedback_capacity)
            .ok()
            .and_then(|n| n.checked_mul(size_of::<RawFeedbackRecord>()))
            .ok_or_else(|| publication_input_error("feedback capacity overflow"))?;
        for (role, index, bytes, capacity, end) in [
            (
                1,
                0,
                publication_abi_bytes(&parent.prefix),
                prefix_capacity,
                parent.prefix.len() as u64,
            ),
            // Output storage only; native initialization fills the actual
            // source digest before this bank can be sealed or acquired.
            (3, 0, vec![0; 32], 32, 0),
            (
                14,
                0,
                vec![0; size_of::<CompletionCoverage>()],
                size_of::<CompletionCoverage>(),
                0,
            ),
            (15, 0, vec![0; feedback_capacity], feedback_capacity, 0),
            (16, 0, statements[0].clone(), statements[0].len(), 0),
            (16, 1, statements[1].clone(), statements[1].len(), 0),
            (16, 2, statements[2].clone(), statements[2].len(), 0),
            (
                33,
                0,
                vec![0; size_of::<AttemptReceipt>()],
                size_of::<AttemptReceipt>(),
                0,
            ),
            (
                47,
                0,
                include_bytes!("semantic_action_catalogue_v1.def").to_vec(),
                include_bytes!("semantic_action_catalogue_v1.def").len(),
                0,
            ),
            (
                48,
                0,
                publication_abi_bytes(&self.codebooks.words),
                self.codebooks.words.len() * 8,
                0,
            ),
            (
                55,
                0,
                tensor_table_bytes(&layout_rows, false, &[])?,
                tensor_table_capacity(layout_rows.len(), 32 + parent.feedback_capacity)?,
                0,
            ),
        ] {
            plans.push(PublicationAllocationPlan {
                role,
                index,
                capacity,
                length: bytes.len(),
                logical_begin: 0,
                logical_end: end,
                payload: PublicationPayload::Metadata(bytes),
            });
        }
        let mut instance = [0u8; 32];
        getrandom::fill(&mut instance)
            .map_err(|error| runtime_error("publication instance entropy", error))?;
        let instance = Identity256::from_bytes(instance);
        let contract = PublicationContract {
            abi: 1,
            range_capacity: plans.len() as u64 + 1,
            prefix_capacity: parent.prefix_capacity,
            window_capacity: 32,
            feedback_capacity: parent.feedback_capacity,
            max_position: parent.max_position,
            pad_token: parent.pad_token,
            terminal_token_count: parent.terminal_tokens.len() as u64,
            final_intent_payload_bytes: parent.final_intent_payload_bytes,
            model_generation: parent.model_generation,
            policy_generation: parent.policy_generation,
            authority_generation: parent.authority_generation,
            semantic_owner: self.graph.transition_arena()[1],
            task_identity,
            topology_identity: parent.topology_identity,
            table_identity: parent.table_identity,
            model_contract_layout: parent.model_contract_layout,
            role_count: 55,
            ..PublicationContract::default()
        };
        let runtime = initial_runtime_contract_record(
            contract,
            &parent.role_counts,
            &parent.terminal_tokens,
            &layouts,
            plans
                .iter()
                .map(|plan| (plan.role, plan.index, plan.capacity))
                .collect(),
            &parent.model_numerical_mode,
            &model_memory,
        )?;
        plans.push(PublicationAllocationPlan {
            role: runtime.role as u64,
            index: runtime.index,
            capacity: runtime.capacity_bytes,
            length: runtime.bytes.len(),
            logical_begin: 0,
            logical_end: 0,
            payload: PublicationPayload::Metadata(runtime.bytes),
        });
        plans.sort_by_key(|plan| (plan.role, plan.index));
        let model_geometry_digest = model_memory.digest(&layouts)?;
        let model_payloads = allocations
            .into_iter()
            .map(PublicationPayload::Tensor)
            .collect::<Vec<_>>();
        let (storage, uploads) = PublicationStorage::allocate(
            &self.provider,
            &plans,
            layouts,
            model_memory,
            &model_payloads,
            contract,
            &parent.terminal_tokens,
            instance,
        )?;
        // Install all destinations and producer owners before the first command
        // that may enqueue. A partial copy failure keeps these owners in Session.
        self.publication = Some(Arc::new(storage));
        self.publication_uploads = uploads;
        self.captured = None;
        let extents = self.base_snapshot.extents();
        let header = PublicationHeader {
            instance,
            ring_head: parent.ring_head,
            prefix_extent: parent.prefix.len() as u64,
            semantic_owner: self.graph.transition_arena()[1],
            semantic_slot: u64::from(self.root.slot()),
            semantic_generation: self.root.generation(),
            semantic_digest: Identity256::from_bytes(*self.base_snapshot.digest().as_bytes()),
            semantic_extents: [
                u64::from(extents.statements()),
                u64::from(extents.supports()),
                u64::from(extents.versions()),
            ],
            model_generation: parent.model_generation,
            neural_generation: parent.neural_generation,
            cache_generation: parent.cache_generation,
            authority_generation: parent.authority_generation,
            fuel: parent.fuel,
            proposal: u64::from(parent.rng.proposal),
            stream_serial: parent.rng.stream_serial,
            family_id: u64::from(parent.rng.family_id),
            training_cursor: parent.training_cursor,
            training_rng: parent.training_rng,
            range_count: contract.range_capacity,
            model_geometry_digest,
            ..PublicationHeader::default()
        };
        let state = DeviceState {
            model_generation: parent.rng.model_generation,
            family_id: u32::from(parent.rng.family_id),
            stream_serial: parent.rng.stream_serial,
            next_proposal: u64::from(parent.rng.proposal),
            catalogue_generation: self.binding().generation,
            catalogue_digest: Identity256::from_bytes(CATALOGUE_DIGEST),
            binding_digest: self.binding().digest,
            ..DeviceState::default()
        };
        let bank = PublicationBank {
            header,
            source: parent.source,
            state,
            receipts: [SemanticTransitionReceipt::default(); COMPONENT_COUNT],
        };
        let result = self.initialize_publication(
            bank,
            &parent.terminal_tokens,
            &parent.role_counts,
            parent.rng,
            1,
            None,
        );
        if let Ok(_predecessor) = &result {
            #[cfg(feature = "semantic-policy")]
            let predecessor = *_predecessor;
            // Publication joins the original model and output snapshots. Only
            // their one-use stage closes: the model and transient seals remain
            // owned by this Session for late original-forward/autograd reads.
            self.retained_initial_prefill =
                self.initial_prefill
                    .take()
                    .map(|mut stage| RetainedInitialPrefillContent {
                        scope: stage.scope,
                        task_identity: stage.task_identity,
                        task_epoch: stage.task_epoch,
                        model_generation: stage.model_generation,
                        model: stage.model_content.take().expect("verified model content"),
                        #[cfg(feature = "semantic-policy")]
                        output: stage
                            .output_content
                            .take()
                            .expect("verified output content"),
                        #[cfg(feature = "semantic-policy")]
                        record: InitialPrefillRecord {
                            predecessor,
                            semantic_root: header.semantic_digest,
                            task_identity,
                            task_epoch: stage.task_epoch,
                            task_content,
                            model_generation: stage.model_generation,
                            tokens: stage.layout.prefill_tokens,
                            mapping: stage.layout.prefill_mapping,
                        },
                        captured: stage.captured_content,
                    });
        } else {
            self.poisoned = true;
        }
        result
    }

    /// Reconstruct native material into this fresh admitted owner. This performs
    /// actual graph insert/seal and native state hashing; it does not establish
    /// an episode's provenance, current use rights, or model replay equivalence.
    /// The trusted execution importer must verify those before issuing TaskUse.
    pub fn restore_state_material(
        &mut self,
        bytes: &[u8],
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.restore_state_material_inner(bytes, None)
    }

    /// Cold-create a private successor from an authentic complete checkpoint.
    /// Only the explicit phase and producer-authorized optimizer reset change;
    /// all effective parameters, caches, native records and progress are copied.
    /// The public Controller retains the old runnable owner until durable handoff.
    pub fn restore_learning_phase_material(
        &mut self,
        bytes: &[u8],
        transition: &SemanticLearningPhaseTransition,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.restore_state_material_inner(bytes, Some(transition))
    }

    fn restore_state_material_inner(
        &mut self,
        bytes: &[u8],
        transition: Option<&SemanticLearningPhaseTransition>,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some() || self.captured.is_some() || self.task.is_none() {
            return Err(publication_input_error(
                "state restoration requires a fresh uncaptured task-bound Session",
            ));
        }
        let mut material = PublicationMaterial::decode(bytes)?;
        let header = material.bank.header;
        let mut rng = header.rng_binding()?;
        let mut fold = None;
        if let Some(transition) = transition {
            let (record, absorption) = transition.apply(&mut material)?;
            material.learning_phases.push(record);
            fold = absorption;
        }
        if fold.is_some() {
            let generation = header
                .model_generation
                .checked_add(1)
                .filter(|n| *n <= u64::from(u32::MAX))
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            material.bank.header.model_generation = generation;
            material.bank.header.neural_generation = header
                .neural_generation
                .checked_add(1)
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            material.bank.state.model_generation = generation as u32;
            rng.model_generation = generation as u32;
        }
        if header.authority_generation == 0 {
            return Err(publication_input_error(
                "restored RNG or task generation exceeds its native domain",
            ));
        }
        // Validate immutable task statements before any graph mutation. Symbols
        // are compared through admitted canonical bytes, never process IDs.
        for (index, statement) in self.feedback_statement_bytes()?.iter().enumerate() {
            let saved = material
                .ranges
                .iter()
                .find(|item| item.range.role == 16 && item.range.index == index as u64)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if saved.bytes != *statement {
                return Err(publication_input_error(
                    "restored feedback statement differs from the actual admitted task",
                ));
            }
        }
        let result = (|| {
            let root = self
                .graph
                .restore_root(&material.graph)
                .map_err(SemanticTransitionError::Semantic)?;
            let snapshot = self
                .graph
                .snapshot(crate::SemanticView::Root(root))
                .map_err(SemanticTransitionError::Semantic)?;
            let admission = self
                .graph
                .admission()
                .ok_or(SemanticTransitionError::NotBound)?;
            let codebooks = ActionCodebooks::derive(
                admission,
                self.graph.transition_arena()[1],
                self.task
                    .as_ref()
                    .and_then(|(task, _)| task.spec.program.editable_program()),
            )?;
            if codebooks.input_cells != self.codebooks.input_cells
                || codebooks.words.len() != self.device_codebooks.len()
            {
                return Err(publication_input_error(
                    "restored action catalogue changes its allocated shape",
                ));
            }
            let (task, device) = self
                .task
                .as_mut()
                .ok_or(SemanticTransitionError::NotBound)?;
            task.admission_identity = admission.identity();
            if task.identity() != material.contract.task_identity {
                return Err(publication_input_error(
                    "restored native task differs from its original complete admission",
                ));
            }
            let words = task.words(self.graph.transition_arena()[1]);
            self.provider
                .htod_sync_copy_into_tracked(&words, device)
                .map_err(|error| runtime_error("restored task owner upload", error))?;
            let codebook = material
                .ranges
                .iter_mut()
                .find(|item| item.range.role == 48)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            codebook.bytes = relocate_publication_codebooks(&codebook.bytes, &codebooks.words)?;
            self.codebooks = codebooks;
            self.upload_cold_codebooks()?;
            self.root = root;
            self.base_snapshot = snapshot;
            self.task_epoch = header.authority_generation;
            self.learning_phases = material.learning_phases;
            let mut instance = [0; 32];
            getrandom::fill(&mut instance)
                .map_err(|error| runtime_error("restored instance entropy", error))?;
            let instance = Identity256::from_bytes(instance);
            if instance == header.instance {
                return Err(publication_input_error(
                    "restoration must create a fresh instance",
                ));
            }
            let mut contract = material.contract;
            contract.semantic_owner = self.graph.transition_arena()[1];
            let plans: Vec<_> = material
                .ranges
                .into_iter()
                .map(|item| PublicationAllocationPlan {
                    role: item.range.role,
                    index: item.range.index,
                    capacity: item.capacity,
                    length: item.bytes.len(),
                    logical_begin: item.range.logical_begin,
                    logical_end: item.range.logical_end,
                    payload: if matches!(item.range.role, 18..=25) {
                        PublicationPayload::Uncomputed
                    } else {
                        PublicationPayload::Metadata(item.bytes)
                    },
                })
                .collect();
            let model_payloads = material
                .model_allocations
                .into_iter()
                .map(PublicationPayload::Metadata)
                .collect::<Vec<_>>();
            let (storage, uploads) = PublicationStorage::allocate(
                &self.provider,
                &plans,
                material.layouts,
                material.model_memory,
                &model_payloads,
                contract,
                &material.terminals,
                instance,
            )?;
            material.bank.header.abi = 0;
            material.bank.header.instance = instance;
            material.bank.header.recovered_instance = header.instance;
            material.bank.header.sealed_epoch = 0;
            material.bank.header.base_word = 0;
            material.bank.header.publication_word = 0;
            material.bank.header.semantic_owner = contract.semantic_owner;
            material.bank.header.semantic_slot = u64::from(root.slot());
            material.bank.header.semantic_generation = root.generation();
            material.bank.header.neural_bank = 0;
            // Historical receipts and feedback stay unchanged. Only the live
            // descriptor is rebound by initialize_publication; its kernel checks
            // fresh native hashes against the saved logical/state expectations.
            self.publication = Some(Arc::new(storage));
            self.publication_uploads = uploads;
            let restored = self.initialize_publication(
                material.bank,
                &material.terminals,
                &material.role_counts,
                rng,
                if fold.is_some() {
                    7
                } else if transition.is_some() {
                    5
                } else {
                    4
                },
                fold.as_ref(),
            )?;
            if transition.is_none()
                && (restored.logical_digest != header.logical_digest
                    || restored.state_digest != header.state_digest)
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            Ok(restored)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Actual phase lineage owned by this Session. This is a cold metadata read,
    /// not a scientific acceptance result or permission to execute training.
    pub fn learning_phase_history(&self) -> &[SemanticLearningPhaseRecord] {
        &self.learning_phases
    }

    /// Admit a new immutable training arena after an exact cold restore, while
    /// its Session is still private. The saved publication is the only source
    /// of model, replay, receipt and optimizer bytes; only the live task
    /// authority binding and its runtime contract are regenerated.
    pub fn rebind_restored_training_arena(
        &mut self,
        source: &[u8],
        witness: SemanticTaskGoalWitness,
        rows: Vec<SemanticTrainingViewRow>,
        objective: SemanticTrainingObjective,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.ensure_quiescent()?;
        if self.poisoned
            || self.captured.is_some()
            || !self.readers.is_empty()
            || self.training_views.is_some()
            || self.task.is_none()
            || self.publication.is_none()
        {
            return Err(publication_input_error(
                "training arena transfer requires one private restored publication",
            ));
        }
        self.task_objective_law()
            .ok_or(SemanticTransitionError::NotBound)?
            .require_objective(&objective)?;
        let result = (|| {
            let mut material = PublicationMaterial::decode(source)?;
            material.require_successful_recompute()?;
            let original = material.bank.header;
            let restored = self.read_publication_header(0)?;
            if restored.recovered_instance != original.instance
                || restored.instance == original.instance
                || restored.publication_word != 0
                || restored.logical_digest != original.logical_digest
                || restored.state_digest != original.state_digest
                || self.task_epoch != original.authority_generation
            {
                return Err(publication_input_error(
                    "training arena source is not the exact private cold restoration",
                ));
            }
            let (task, _) = self
                .task
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?;
            let old_witness = task.goal_witness.ok_or(SemanticTransitionError::NotBound)?;
            if task.identity() != material.contract.task_identity
                || witness.semantic_root != old_witness.semantic_root
                || witness.mandatory_link_count == 0
                || witness.constraint_count == 0
                || witness
                    .authority_root
                    .as_bytes()
                    .iter()
                    .all(|byte| *byte == 0)
                || witness
                    .mandatory_links_root
                    .as_bytes()
                    .iter()
                    .all(|byte| *byte == 0)
                || witness
                    .constraints_root
                    .as_bytes()
                    .iter()
                    .all(|byte| *byte == 0)
            {
                return Err(publication_input_error(
                    "training arena transfer changed the original task content or semantic goal",
                ));
            }
            let next_epoch = self
                .task_epoch
                .checked_add(1)
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            let model_mode = material.model_numerical_mode()?.to_vec();
            let (task, device) = self
                .task
                .as_mut()
                .ok_or(SemanticTransitionError::NotBound)?;
            task.goal_witness = Some(witness);
            let task_identity = task.identity();
            if task_identity == material.contract.task_identity {
                return Err(publication_input_error(
                    "training arena transfer requires a new current authority binding",
                ));
            }
            let words = task.words(self.graph.transition_arena()[1]);
            self.provider
                .htod_sync_copy_into_tracked(&words, device)
                .map_err(|error| runtime_error("training arena task owner upload", error))?;
            self.training_views = Some(SemanticTrainingViewArena::allocate(
                &self.provider,
                &self.domain,
                rows,
                objective,
                task.spec.training_domain.as_ref().ok_or_else(|| {
                    publication_input_error(
                        "training arena transfer requires the original pre-action input domain",
                    )
                })?,
                task_identity,
                task.content().0,
                task.content().1,
            )?);
            material.contract.task_identity = task_identity;
            material.contract.authority_generation = next_epoch;
            material.contract.semantic_owner = self.graph.transition_arena()[1];
            let capacities = material
                .ranges
                .iter()
                .filter(|item| item.range.role != 43)
                .map(|item| (item.range.role, item.range.index, item.capacity))
                .collect();
            let runtime = initial_runtime_contract_record(
                material.contract,
                &material.role_counts,
                &material.terminals,
                &material.layouts,
                capacities,
                &model_mode,
                &material.model_memory,
            )?;
            let runtime_range = material
                .ranges
                .iter_mut()
                .find(|item| item.range.role == 43 && item.range.index == 0)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if runtime.bytes.len() > runtime_range.capacity {
                return Err(publication_input_error(
                    "training arena runtime contract exceeds its retained allocation",
                ));
            }
            runtime_range.bytes = runtime.bytes;
            let plans = material
                .ranges
                .into_iter()
                .map(|item| PublicationAllocationPlan {
                    role: item.range.role,
                    index: item.range.index,
                    capacity: item.capacity,
                    length: item.bytes.len(),
                    logical_begin: item.range.logical_begin,
                    logical_end: item.range.logical_end,
                    payload: if matches!(item.range.role, 18..=25) {
                        PublicationPayload::Uncomputed
                    } else {
                        PublicationPayload::Metadata(item.bytes)
                    },
                })
                .collect::<Vec<_>>();
            let model_payloads = material
                .model_allocations
                .into_iter()
                .map(PublicationPayload::Metadata)
                .collect::<Vec<_>>();
            let mut instance = [0u8; 32];
            getrandom::fill(&mut instance)
                .map_err(|error| runtime_error("training arena instance entropy", error))?;
            let instance = Identity256::from_bytes(instance);
            if instance == original.instance || instance == restored.instance {
                return Err(publication_input_error(
                    "training arena requires a fresh instance",
                ));
            }
            let (storage, uploads) = PublicationStorage::allocate(
                &self.provider,
                &plans,
                material.layouts,
                material.model_memory,
                &model_payloads,
                material.contract,
                &material.terminals,
                instance,
            )?;
            let mut bank = material.bank;
            bank.header.abi = 0;
            bank.header.instance = instance;
            bank.header.recovered_instance = original.instance;
            bank.header.sealed_epoch = 0;
            bank.header.base_word = 0;
            bank.header.publication_word = 0;
            bank.header.semantic_owner = material.contract.semantic_owner;
            bank.header.semantic_slot = u64::from(self.root.slot());
            bank.header.semantic_generation = self.root.generation();
            bank.header.neural_bank = 0;
            bank.header.authority_generation = next_epoch;
            self.publication = Some(Arc::new(storage));
            self.publication_uploads = uploads;
            self.task_epoch = next_epoch;
            let published = self.initialize_publication(
                bank,
                &material.terminals,
                &material.role_counts,
                original.rng_binding()?,
                5,
                None,
            )?;
            if published.logical_digest == original.logical_digest
                || published.state_digest == original.state_digest
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            Ok(published)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Re-read the selected publication after its external model owner has been
    /// reconstructed and prove that it is still the fresh instance recovered
    /// from these exact original logical and state roots.
    pub fn verify_restored_state_material(
        &mut self,
        lease: &SemanticPublishedLease,
        bytes: &[u8],
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        let expected = PublicationMaterial::decode(bytes)?;
        let actual = PublicationMaterial::decode(&self.published_state_material(lease)?)?;
        if expected.learning_phases != actual.learning_phases {
            return Err(publication_input_error(
                "checkpoint restore changed retained learning-phase history",
            ));
        }
        let expected = expected.bank.header;
        let header = actual.bank.header;
        if header.instance == expected.instance
            || header.recovered_instance != expected.instance
            || header.publication_word != 0
            || header.logical_digest != expected.logical_digest
            || header.state_digest != expected.state_digest
        {
            return Err(publication_input_error(
                "checkpoint restore no longer owns the exact fresh recovered publication",
            ));
        }
        self.published_identity(lease)
    }

    /// Snapshot the original prefill while its model and output producers are
    /// still owned. Later checkpoints reuse these exact seals, never a new
    /// baseline from a post-action model or restored publication.
    pub fn checkpoint_initial_prefill_material(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<(Vec<u8>, bool), SemanticTransitionError> {
        self.ensure_quiescent()?;
        self.checked_reader(lease)?;
        #[cfg(feature = "semantic-policy")]
        if let Some(record) = self
            .retained_initial_prefill
            .as_ref()
            .map(|retained| retained.record.clone())
        {
            let content = self
                .original_initial_prefill_content(
                    record.predecessor,
                    record.semantic_root,
                    record.tokens.len() as u64,
                    record.model_generation,
                    record.task_identity,
                    record.task_content,
                )?
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if let Some(saved) = &self.checkpoint_initial_prefill {
                if saved.original != record.predecessor || saved.content != content {
                    self.poisoned = true;
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
            } else {
                self.checkpoint_initial_prefill = Some(CheckpointInitialPrefill {
                    original: record.predecessor,
                    content,
                    recovery_referent: None,
                });
            }
        }
        Ok((
            CheckpointInitialPrefill::encode_section(self.checkpoint_initial_prefill.as_ref())?,
            self.checkpoint_initial_prefill.is_some(),
        ))
    }

    pub fn verify_checkpoint_initial_prefill_source(
        section: &[u8],
        native: &[u8],
        task_identity: Identity256,
        task_epoch: u64,
        task_content: SemanticTaskContentIdentity,
        require_original_publication: bool,
    ) -> Result<bool, SemanticTransitionError> {
        let Some(prefill) = CheckpointInitialPrefill::decode_section(section)? else {
            return Ok(false);
        };
        let material = PublicationMaterial::decode(native)?;
        let header = material.bank.header;
        let original = SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        };
        if material.contract.task_identity != task_identity
            || prefill.original.word != 0
            || (require_original_publication && prefill.original != original)
        {
            return Err(publication_input_error(
                "checkpoint initial prefill names another original publication or task",
            ));
        }
        if prefill.original == original {
            prefill.verify_content(
                header.semantic_digest,
                header.model_generation,
                task_identity,
                task_epoch,
                task_content,
                header.prefix_extent,
            )?;
        } else {
            prefill.verify_recorded_content(task_identity, task_epoch, task_content)?;
        }
        Ok(true)
    }

    /// Bind a restored pre-action publication to the exact original prefill
    /// section and compact reference of the full checkpoint that carried it.
    pub fn bind_restored_checkpoint_initial_prefill(
        &mut self,
        lease: &SemanticPublishedLease,
        native: &[u8],
        section: &[u8],
        referent: &[u8],
    ) -> Result<(), SemanticTransitionError> {
        if self.checkpoint_initial_prefill.is_some() || referent.is_empty() {
            return Err(publication_input_error(
                "restored initial prefill is already bound or has no source reference",
            ));
        }
        self.verify_restored_state_material(lease, native)?;
        let original_header = PublicationMaterial::decode(native)?.bank.header;
        let original = SemanticPublishedIdentity {
            instance: original_header.instance,
            word: original_header.publication_word,
            logical_digest: original_header.logical_digest,
            state_digest: original_header.state_digest,
        };
        let mut prefill = CheckpointInitialPrefill::decode_section(section)?.ok_or_else(|| {
            publication_input_error("pre-action checkpoint has no original initial prefill")
        })?;
        let task_identity = self
            .task_evaluation_identity()
            .ok_or(SemanticTransitionError::NotBound)?;
        let (task_content, _) = self
            .task_content()
            .ok_or(SemanticTransitionError::NotBound)?;
        if prefill.original != original {
            return Err(publication_input_error(
                "checkpoint prefill names another original publication",
            ));
        }
        prefill.verify_content(
            original_header.semantic_digest,
            original_header.model_generation,
            task_identity,
            self.task_epoch,
            task_content,
            original_header.prefix_extent,
        )?;
        prefill.recovery_referent = Some(referent.to_vec());
        self.checkpoint_initial_prefill = Some(prefill);
        Ok(())
    }

    fn initialize_publication(
        &mut self,
        bank: PublicationBank,
        terminal_tokens: &[u64],
        role_counts: &[u64; 55],
        rng: SemanticRngBinding,
        operation: u64,
        fold: Option<&learning_phase::LearningFoldPlan>,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .expect("installed publication owner"),
        );
        let mut recorder = self.domain.new_strict_recorder();
        storage.record(&mut recorder);
        for (_, payload) in &self.publication_uploads {
            if let PublicationPayload::Tensor(tensor) = payload {
                if let Some(source) = &tensor.source {
                    recorder.read(source);
                }
            }
        }
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            for allocation in &storage.allocations {
                // A genuine empty model buffer retains an owner and layout,
                // but has no device pointer on which to submit a memory write.
                if allocation.is_empty() {
                    continue;
                }
                // SAFETY: all actual fixed allocations were recorded before this
                // first may-enqueue boundary; zero bytes do not mark a bank valid.
                unsafe {
                    sys::cuMemsetD8Async(
                        allocation.device_ptr_value(),
                        0,
                        allocation.len(),
                        enqueue.stream().cu_stream(),
                    )
                }
                .result()
                .map_err(|error| XlogError::Kernel(error.to_string()))?;
            }
            for (slot, payload) in &self.publication_uploads {
                if let PublicationPayload::Tensor(tensor) = payload {
                    if let Some(source) = &tensor.source {
                        let destination = &storage.allocations[*slot];
                        let layout = if tensor.layout.role == 0 {
                            &tensor.layout
                        } else {
                            &storage.layouts[&(tensor.layout.role, tensor.layout.index)]
                        };
                        for (source_offset, destination_offset, bytes) in
                            tensor_copy_plan(&tensor.layout, layout)
                                .map_err(|error| XlogError::Kernel(error.to_string()))?
                        {
                            unsafe {
                                sys::cuMemcpyDtoDAsync_v2(
                                    destination.device_ptr_value() + destination_offset,
                                    *source.device_ptr() + source_offset,
                                    bytes,
                                    enqueue.stream().cu_stream(),
                                )
                            }
                            .result()
                            .map_err(|error| XlogError::Kernel(error.to_string()))?;
                        }
                    }
                }
            }
            Ok::<(), XlogError>(())
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "cold publication tensor snapshot",
            CudaStream::synchronize,
        )?;
        for (slot, payload) in &self.publication_uploads {
            if let PublicationPayload::Metadata(bytes) = payload {
                if !bytes.is_empty() {
                    let mut destination = storage.allocations[*slot].view().slice(..bytes.len());
                    self.provider
                        .htod_launch_metadata_sync_copy_into(bytes, &mut destination)
                        .map_err(|error| runtime_error("cold publication record upload", error))?;
                }
            }
        }
        if let Some(fold) = fold {
            self.apply_learning_fold(fold)?;
        }
        upload_publication(&self.provider, &[bank], &storage.banks[0])?;
        upload_publication(&self.provider, &[bank], &storage.banks[1])?;
        for bank in 0..2 {
            upload_publication(
                &self.provider,
                &storage.bank_templates[bank],
                &storage.directories[bank],
            )?;
        }
        let entries: Vec<_> = storage
            .allocations
            .iter()
            .map(|allocation| PublicationStorageEntry {
                pointer: allocation.device_ptr_value(),
                bytes: allocation.len() as u64,
                generation: 1,
            })
            .collect();
        upload_publication(&self.provider, &entries, &storage.storage)?;
        upload_publication(&self.provider, &[storage.contract_value], &storage.contract)?;
        upload_publication(&self.provider, terminal_tokens, &storage.terminals)?;
        let counts: Vec<_> = role_counts
            .iter()
            .enumerate()
            .map(|(index, &count)| PublicationRoleCount {
                role: index as u64 + 1,
                count,
            })
            .collect();
        upload_publication(&self.provider, &counts, &storage.role_counts)?;
        upload_publication(
            &self.provider,
            &[PendingContinuation {
                abi: 1,
                ranges: storage.continuation_directory.device_ptr_value(),
                range_count: storage.continuation_templates.len() as u64,
                ..PendingContinuation::default()
            }],
            &storage.continuation,
        )?;
        upload_publication(
            &self.provider,
            &storage.continuation_templates,
            &storage.continuation_directory,
        )?;
        upload_publication(
            &self.provider,
            &[PublicationControl {
                abi: 1,
                instance: storage.instance,
                banks: storage.banks.each_ref().map(|bank| bank.device_ptr_value()),
                directories: storage
                    .directories
                    .each_ref()
                    .map(|directory| directory.device_ptr_value()),
                storage: storage.storage.device_ptr_value(),
                storage_count: storage.allocations.len() as u64,
                contract: storage.contract.device_ptr_value(),
                continuation: storage.continuation.device_ptr_value(),
                ..PublicationControl::default()
            }],
            &storage.control,
        )?;
        self.upload_rng_state(self.binding(), rng)?;
        self.publication_command(operation, None)?;
        let control = self.publication_read(storage.control.view())?[0];
        if control.refusal != 0 {
            return Err(SemanticTransitionError::PublicationRefused {
                status: control.refusal,
            });
        }
        let header = self.read_publication_header(0)?;
        if header.abi != 1
            || header.instance != storage.instance
            || header.publication_word != 0
            || control.word != 0
            || header.model_geometry_digest != bank.header.model_geometry_digest
            || (operation == 4
                && header.model_numerical_digest != bank.header.model_numerical_digest)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        self.publication_uploads.clear();
        self.rng = Some(rng);
        self.next_proposal = u64::from(rng.proposal);
        Ok(SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        })
    }

    fn publication_command(
        &mut self,
        operation: u64,
        token: Option<u64>,
    ) -> Result<(), SemanticTransitionError> {
        let storage = self
            .publication
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        let mut descriptor = self.descriptor();
        descriptor.publication = PublicationCommand {
            control: storage.control.device_ptr_value(),
            operation,
            lease: token.map_or(0, |token| self.readers[&token].device.device_ptr_value()),
        };
        let mut recorder = self.kernel_recorder();
        if let Some(token) = token {
            recorder.read_write(&self.readers[&token].device);
        }
        let execute = self.execute.clone();
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |stream| {
            // SAFETY: command, bank directories, storage and optional lease all
            // have actual recorded owners, and the common descriptor ABI is fixed.
            unsafe {
                execute.launch_in(
                    stream,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (256, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (descriptor,),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "publication command completion",
            CudaStream::synchronize,
        )
    }

    fn publication_read<T: DeviceRepr + Copy>(
        &mut self,
        source: DeviceMemoryView<T>,
    ) -> Result<Vec<T>, SemanticTransitionError> {
        let bytes = source
            .len()
            .checked_mul(size_of::<T>())
            .ok_or_else(|| publication_input_error("publication metadata read overflow"))?;
        let mut pinned = crate::device::PinnedHostBuffer::new(&self.stream, bytes)
            .map_err(|error| runtime_error("publication metadata staging", error))?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&source);
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |stream| {
            // SAFETY: recorder retains the complete source; pinned owner retains
            // its destination across enqueue failures and the final stream wait.
            unsafe {
                pinned.enqueue(stream.stream(), |destination| {
                    sys::cuMemcpyDtoHAsync_v2(
                        destination.cast(),
                        *source.device_ptr(),
                        bytes,
                        stream.stream().cu_stream(),
                    )
                    .result()
                })
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "publication metadata read completion",
            CudaStream::synchronize,
        )?;
        // SAFETY: the entire integral ABI slice completed its recorded copy.
        let result = unsafe { pinned.read_vec::<T>(source.len()) }
            .map_err(|error| runtime_error("publication metadata read", error))?;
        self.provider
            .record_final_observation_transfer(bytes as u64);
        Ok(result)
    }

    fn read_publication_header(
        &mut self,
        bank: usize,
    ) -> Result<PublicationHeader, SemanticTransitionError> {
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        // SAFETY: PublicationBank starts with one initialized fixed Header and
        // the tracked allocation has sufficient alignment and checked ABI extent.
        let view = unsafe {
            storage.banks[bank]
                .view()
                .cast::<u8>()
                .expect("byte-aligned bank ABI")
                .slice(..size_of::<PublicationHeader>())
                .cast::<PublicationHeader>()
                .expect("aligned fixed header ABI")
        };
        Ok(self.publication_read(view)?[0])
    }

    pub fn acquire(&mut self) -> Result<SemanticPublishedLease, SemanticTransitionError> {
        if self.pending {
            let proposal = u32::try_from(self.next_proposal)
                .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
            // Complete and reconcile the actual CAS outcome before returning a
            // reader. A failed publication can never return the old base as progress.
            self.observe(proposal)?.into_published()?;
        }
        self.ensure_quiescent()?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let token = self
            .next_reader
            .checked_add(1)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        self.next_reader = token;
        let device = allocate_publication(&self.provider, 1)?;
        self.steps.insert(token, StepContentStorage::new());
        self.readers.insert(
            token,
            PublishedReader {
                device,
                aliases: Arc::new(()),
                consumer_streams: BTreeSet::new(),
            },
        );
        // Lease storage is retained before upload or Acquire can enqueue.
        if let Err(error) = upload_publication(
            &self.provider,
            &[PublicationLease::default()],
            &self.readers[&token].device,
        ) {
            self.poisoned = true;
            return Err(error);
        }
        self.publication_command(2, Some(token))?;
        let lease = self.publication_read(self.readers[&token].device.view())?[0];
        if lease.status != 0 {
            self.readers.remove(&token);
            self.steps.remove(&token);
            return Err(SemanticTransitionError::PublicationRefused {
                status: lease.status,
            });
        }
        if lease.abi != 1
            || lease.active != 1
            || lease.instance != storage.instance
            || lease.bank > 1
            || lease.bank != (lease.word & 1)
            || lease.epoch != lease.word >> 1
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let header = self.read_publication_header(lease.bank as usize)?;
        let directory = self.publication_read(storage.directories[lease.bank as usize].view())?;
        // SAFETY: source follows Header in the checked fixed bank ABI; no private
        // task observation/result bytes are included in this metadata transfer.
        let source_view = unsafe {
            storage.banks[lease.bank as usize]
                .view()
                .cast::<u8>()
                .expect("byte-aligned bank ABI")
                .slice(
                    size_of::<PublicationHeader>()
                        ..size_of::<PublicationHeader>() + 32 * size_of::<SemanticTextSlot>(),
                )
                .cast::<SemanticTextSlot>()
                .expect("aligned fixed source ABI")
        };
        let source: [SemanticTextSlot; 32] = self
            .publication_read(source_view)?
            .try_into()
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        if header.abi != 1
            || header.instance != lease.instance
            || header.publication_word != lease.word
            || header.sealed_epoch != lease.epoch
            || header.range_count as usize != directory.len()
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let identity = SemanticPublishedIdentity {
            instance: lease.instance,
            word: lease.word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        };
        self.steps
            .get_mut(&token)
            .expect("installed acquisition step")
            .identity = Some(identity);
        Ok(SemanticPublishedLease {
            issuer: Arc::clone(&self.publication_issuer),
            token,
            identity,
            header,
            source,
            directory,
            active: true,
        })
    }

    fn checked_reader(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<&PublishedReader, SemanticTransitionError> {
        self.ensure_quiescent()?;
        if !lease.active || !Arc::ptr_eq(&lease.issuer, &self.publication_issuer) {
            return Err(publication_input_error(
                "lease is released or belongs to a different Session",
            ));
        }
        self.readers
            .get(&lease.token)
            .ok_or_else(|| publication_input_error("lease has no live native reader owner"))
    }

    fn checked_step(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<&StepContentStorage, SemanticTransitionError> {
        self.ensure_quiescent()?;
        if !Arc::ptr_eq(&lease.issuer, &self.publication_issuer) {
            return Err(publication_input_error(
                "retained step belongs to a different Session",
            ));
        }
        let step = self
            .steps
            .get(&lease.token)
            .ok_or_else(|| publication_input_error("original step has been fully released"))?;
        if step.identity != Some(lease.identity)
            || lease.active != self.readers.contains_key(&lease.token)
        {
            return Err(publication_input_error(
                "retained step differs from its original acquired identity",
            ));
        }
        Ok(step)
    }

    /// Authenticate the original step even after its publication bank retires.
    /// This grants no publication access and refuses poisoned or released owners.
    pub fn retained_step_identity(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.checked_step(lease)?;
        Ok(lease.identity)
    }

    /// Prove full consumer retirement of this original publication owner.
    /// A retired bank alone, an abort, or a failed identity lookup is not proof
    /// that its retained steps, evaluations and captured executables are gone.
    pub fn require_retired_publication(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        #[cfg(feature = "semantic-policy")]
        self.require_closed_evaluations()?;
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        if !Arc::ptr_eq(&lease.issuer, &self.publication_issuer)
            || lease.active
            || !self.readers.is_empty()
            || !self.steps.is_empty()
            || self.captured.is_some()
            || self.prepared_segment.is_some()
            || !self.prepared_resources.is_empty()
        {
            return Err(publication_input_error(
                "private publication requires known full retirement of its original consumers",
            ));
        }
        Ok(())
    }

    pub fn published_identity(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.checked_reader(lease)?;
        Ok(lease.identity)
    }

    /// The selected parent must still be the current native publication, and
    /// its own sealed attempt must be a successful recompute. A later publish
    /// invalidates this admission source; a nonpublishing refusal does not.
    pub fn current_recompute_state_material(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let control = self.publication_read(storage.control.view())?[0];
        if control.abi != 1
            || control.instance != lease.identity.instance
            || control.word != lease.identity.word
        {
            return Err(publication_input_error(
                "selected recompute is no longer the current publication",
            ));
        }
        let material = self.published_state_material(lease)?;
        PublicationMaterial::decode(&material)?.require_successful_recompute()?;
        Ok(material)
    }

    /// Complete ordered role/index roster from this acquired directory, not a
    /// prediction from role counts or a read of a newer publication. This is
    /// cached structural metadata; it does not certify current tensor bytes.
    pub fn published_range_keys(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<Vec<(SemanticStateRole, u64)>, SemanticTransitionError> {
        self.checked_reader(lease)?;
        lease
            .directory
            .iter()
            .map(|range| {
                SemanticStateRole::from_code(range.role)
                    .map(|role| (role, range.index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)
            })
            .collect()
    }

    // These event edges are enqueue-only. The producer protocol targets the
    // legacy default stream; caller-declared hook writes target consumer_stream.
    // Every event/owner is retained before a may-enqueue boundary. No host wait
    // or digest/status transfer is performed on this successful path.
    fn order_content_inputs(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.readers
            .get_mut(&lease.token)
            .expect("validated publication reader")
            .consumer_streams
            .insert(consumer_stream);
        self.order_step_content_inputs(lease.token, consumer_stream)
    }

    fn order_step_content_inputs(
        &mut self,
        reader_token: u64,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.steps
            .get_mut(&reader_token)
            .expect("validated content step")
            .consumer_streams
            .insert(consumer_stream);
        self.order_tensor_producer_inputs(consumer_stream)
    }

    fn order_tensor_producer_inputs(
        &mut self,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let consumer = dlpack_consumer_stream(consumer_stream)?;
        self.stream
            .context()
            .bind_to_thread()
            .map_err(|e| runtime_error("content context binding", e))?;
        for source in [std::ptr::null_mut(), consumer] {
            let event = self
                .stream
                .context()
                .new_event(None)
                .map_err(|e| runtime_error("content producer event", e))?;
            self.release_events.push(event);
            let event = self.release_events.last().expect("retained content event");
            // SAFETY: the controlling application supplies a live same-context
            // CUDA stream, after all its writers. The native stream then waits
            // on this exact recorded event, not on future unrelated writes.
            unsafe { cudarc::driver::result::event::record(event.cu_event(), source) }
                .map_err(|e| runtime_error("content producer event record", e))?;
            self.stream
                .wait(event)
                .map_err(|e| runtime_error("content producer event join", e))?;
        }
        Ok(())
    }

    fn order_content_consumers(
        &mut self,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let event = self
            .stream
            .context()
            .new_event(None)
            .map_err(|e| runtime_error("content guard event", e))?;
        self.release_events.push(event);
        let event = self
            .release_events
            .last()
            .expect("retained content guard event");
        // SAFETY: record follows the guard on the admitted native stream. The
        // consumer must enqueue all dependent reads after this method returns.
        // CUDA events provide the dependency without a host synchronization.
        unsafe {
            cudarc::driver::result::event::record(event.cu_event(), self.stream.cu_stream())
                .map_err(|e| runtime_error("content guard event record", e))?;
            sys::cuStreamWaitEvent(
                dlpack_consumer_stream(consumer_stream)?,
                event.cu_event(),
                0,
            )
            .result()
            .map_err(|e| runtime_error("content guard consumer join", e))?;
        }
        Ok(())
    }

    /// Enqueue a live-content check against this reader's original range seals.
    /// Call after hooks/writers and before reads on the declared consumer stream.
    /// Integrity corruption invokes an unconditional device trap: the isolated
    /// task process must terminate, not reset or reuse its Session/tensors.
    /// A successful return means enqueued, not GPU-complete or accepted output.
    /// Concurrent external alias writes through the end of consumption are forbidden.
    pub fn guard_published_content(
        &mut self,
        lease: &SemanticPublishedLease,
        keys: &[(SemanticStateRole, u64)],
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_reader(lease)?;
        dlpack_consumer_stream(consumer_stream)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let inputs = if keys
            .iter()
            .any(|(role, _)| matches!(*role as u64, 1 | 3..=13))
        {
            self.steps[&lease.token].inputs.as_ref().map(Arc::clone)
        } else {
            None
        };
        let directory = &storage.directories[(lease.identity.word & 1) as usize];
        let mut distinct = BTreeSet::new();
        let mut ranges = Vec::with_capacity(keys.len());
        if keys.is_empty() {
            return Err(publication_input_error(
                "content guard requires actual publication ranges",
            ));
        }
        for &(role, index) in keys {
            let key = (role as u64, index);
            if !distinct.insert(key) {
                return Err(publication_input_error(
                    "content guard has duplicate publication ranges",
                ));
            }
            let (range_index, &range) = lease
                .directory
                .iter()
                .enumerate()
                .find(|(_, range)| (range.role, range.index) == key)
                .ok_or_else(|| {
                    publication_input_error("content guard names an absent publication range")
                })?;
            if range_index >= directory.len() {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let allocation = storage
                .allocations
                .get(range.storage_slot as usize)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if range.generation != 1
                || range
                    .offset_bytes
                    .checked_add(range.length_bytes)
                    .is_none_or(|end| end > allocation.len() as u64)
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let layout = if is_tensor_role(role as u64) {
                *storage
                    .layouts
                    .get(&key)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?
            } else {
                SemanticTensorLayout::default()
            };
            // PrefixSource is sealed as raw records. Its synthetic U64 export
            // layout is intentionally not substituted into this hash domain.
            // The original seal remains on the device. Passing its host-cached
            // digest as a launch argument would itself be a digest transfer.
            ranges.push((role as u64, index, layout));
        }
        let execute = self
            .provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_publication_content_guard",
            )
            .ok_or_else(|| {
                runtime_error("kernel lookup", "publication content guard unavailable")
            })?;
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|e| runtime_error("content guard stream admission", e))?;
        let result = (|| {
            self.order_content_inputs(lease, consumer_stream)?;
            if let Some(inputs) = &inputs {
                // Existing guards must cover the actual exported private
                // inputs as well as the still-acquired publication bank.
                self.steps
                    .get_mut(&lease.token)
                    .expect("validated input step")
                    .consumer_streams
                    .insert(consumer_stream);
                inputs.verify(&self.domain, &mut self.poisoned)?;
            }
            for (role, index, layout) in ranges {
                let reader = self
                    .readers
                    .get(&lease.token)
                    .expect("validated native reader");
                storage.enqueue_content_guard(
                    &self.domain,
                    &mut self.poisoned,
                    reader.device.view(),
                    &execute,
                    role,
                    index,
                    layout,
                )?;
            }
            self.order_content_consumers(consumer_stream)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    /// Capture private device digests after the trusted original computation,
    /// before public hooks. This establishes stability, never derivation or rights.
    /// The model owner must attach the issued witness to its original execution.
    /// Native feedback and fixed input aliases verify their original producer
    /// seals; their exact type, shape, interval and coordinate are preserved.
    /// Requires stream-ordered allocation support; a synchronizing allocator is
    /// never substituted for this enqueue-only path.
    pub fn capture_tensor_content(
        &mut self,
        lease: &SemanticPublishedLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticTensorContentWitness, SemanticTransitionError> {
        self.bind_tensor_content(lease, tensors, consumer_stream, false)
    }

    /// Bind the complete live model roster to this parent's originally sealed
    /// model content and generation. A new reader receives a new witness, not a
    /// new baseline. Initial physical layout/address may differ; later verify
    /// retains this invocation's exact producer storage and layout. Enqueue-only.
    pub fn bind_model_content(
        &mut self,
        lease: &SemanticPublishedLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<SemanticTensorContentWitness, SemanticTransitionError> {
        self.bind_tensor_content(lease, tensors, consumer_stream, true)
    }

    fn bind_tensor_content(
        &mut self,
        lease: &SemanticPublishedLease,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
        model: bool,
    ) -> Result<SemanticTensorContentWitness, SemanticTransitionError> {
        let empty = tensors.is_empty();
        let mut handoff = RetainedTensorAdmission {
            inputs: Some(tensors),
            stream: Arc::clone(self.provider.device().inner().stream()),
            ready: false,
        };
        self.checked_reader(lease)?;
        dlpack_consumer_stream(consumer_stream)?;
        if empty {
            return Err(publication_input_error(
                "content witness requires an actual tensor roster",
            ));
        }
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|e| runtime_error("content binding stream admission", e))?;
        if !self
            .provider
            .device()
            .inner()
            .stream()
            .context()
            .has_async_alloc()
        {
            return Err(publication_input_error(
                "device content capture requires stream-ordered CUDA allocation support",
            ));
        }
        // Include even rejected handoffs in final retirement. Post-import
        // interval/allocation errors must not hide this caller's writer stream.
        self.steps
            .get_mut(&lease.token)
            .expect("validated content step")
            .consumer_streams
            .insert(consumer_stream);
        let tensors = prepare_semantic_tensors(
            &self.provider,
            handoff
                .inputs
                .take()
                .expect("retained original content inputs"),
        )?;
        let reader = self
            .steps
            .get_mut(&lease.token)
            .expect("validated content step");
        let index = reader.content.len();
        reader.content.push(TensorContentBuffers {
            tensors,
            seals: TensorContentSeals::Captured(Vec::new()),
            verification_inputs: Vec::new(),
        });
        let reader = &self.steps[&lease.token];
        let content = &reader.content[index];
        validate_content_coordinates(
            content
                .tensors
                .iter()
                .map(|tensor| (tensor.layout.role, tensor.layout.index)),
        )?;
        let mut native_origins = Vec::with_capacity(content.tensors.len());
        for tensor in &content.tensors {
            let mut original = None;
            if !model {
                // Shared prefix/key-value storage can belong to older steps
                // too. Match the actual current step before checking foreign
                // private owners, preserving its original logical interval.
                if let Some(inputs) = &reader.inputs {
                    if inputs.owns_tensor(tensor)? {
                        original = Some(Arc::clone(inputs));
                    }
                }
                if original.is_none() {
                    for (&token, owner) in &self.steps {
                        if token == lease.token {
                            continue;
                        }
                        if let Some(inputs) = &owner.inputs {
                            if inputs.owns_tensor(tensor)? {
                                return Err(publication_input_error(
                                    "native step content belongs to another acquired reader",
                                ));
                            }
                        }
                    }
                }
            }
            if original.is_none() {
                tensor_content_range(
                    &tensor.layout,
                    tensor.logical_begin,
                    tensor.logical_end,
                    tensor.source.as_ref().map_or(0, DeviceMemoryView::len),
                )?;
            }
            native_origins.push(original);
        }
        let model_plan = if model {
            let storage = self
                .publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?;
            let ranges = model_content_ranges(
                &lease.directory,
                &storage.layouts,
                content.tensors.iter().map(|tensor| {
                    (
                        tensor.layout,
                        tensor.logical_begin,
                        tensor.logical_end,
                        tensor.source.as_ref().map_or(0, DeviceMemoryView::len),
                    )
                }),
            )?;
            Some(model_content_copy_plan(
                &lease.directory,
                &ranges,
                &storage
                    .allocations
                    .iter()
                    .map(TrackedCudaSlice::len)
                    .collect::<Vec<_>>(),
            )?)
        } else {
            None
        };
        let seals = if let Some(plan) = &model_plan {
            TensorContentSeals::Model(ModelContentSeals::allocate(&self.provider, plan)?)
        } else {
            let mut digests = Vec::with_capacity(content.tensors.len());
            for (tensor, native) in content.tensors.iter().zip(native_origins) {
                if let Some(inputs) = native {
                    digests.push(CapturedTensorDigest::Publication(inputs));
                    continue;
                }
                let mut origin = None;
                for (&token, owner) in &self.steps {
                    if let Some(digest) = owner.feedback_origin_digest(tensor)? {
                        if token != lease.token {
                            return Err(publication_input_error(
                                "native feedback content belongs to another acquired reader",
                            ));
                        }
                        origin = Some(digest);
                        break;
                    }
                }
                digests.push(match origin {
                    Some(original) => original,
                    None => {
                        if tensor.native_allocation.is_some() {
                            return Err(publication_input_error("native allocation origin has no original content producer in this acquired reader"));
                        }
                        CapturedTensorDigest::Tensor {
                            cells: Arc::new(allocate_publication(&self.provider, 4)?), offset: 0, producer_sealed: false,
                        }
                    }
                });
            }
            TensorContentSeals::Captured(digests)
        };
        let handle = SemanticTensorContentWitness {
            issuer: Arc::clone(&self.publication_issuer),
            reader_token: lease.token,
            index,
            _witness: Arc::clone(&reader.content_witnesses),
        };
        self.steps
            .get_mut(&lease.token)
            .expect("validated content step")
            .content[index]
            .seals = seals;
        if let Some(plan) = model_plan {
            // Validate the original contract while the actual reader still pins
            // its directory. Then preserve those expected seals and contract
            // bytes, never a new digest of the supplied numerical model.
            self.guard_published_content(
                lease,
                &[(SemanticStateRole::ModelContract, 0)],
                consumer_stream,
            )?;
            let storage = self
                .publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?;
            let TensorContentSeals::Model(model) = &self.steps[&lease.token].content[index].seals
            else {
                return Err(SemanticTransitionError::ObservationMismatch);
            };
            model.snapshot(
                &self.domain,
                &mut self.poisoned,
                &storage.directories[(lease.identity.word & 1) as usize],
                &storage.allocations[plan.contract_storage_slot],
                &plan,
            )?;
        }
        self.enqueue_tensor_content(lease, &handle, consumer_stream, model)?;
        Ok(handle)
    }

    /// Verify the actual consumer tensors against the original private witness.
    /// Metadata/pointer substitution is a typed input refusal; later byte mutation
    /// is a terminal device integrity error. Return is enqueue-only. Ordinary
    /// completion/observation must succeed before activating outputs or replay.
    pub fn verify_tensor_content(
        &mut self,
        lease: &SemanticPublishedLease,
        witness: &SemanticTensorContentWitness,
        tensors: Vec<SemanticTensorInput>,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let mut handoff = RetainedTensorAdmission {
            inputs: Some(tensors),
            stream: Arc::clone(self.provider.device().inner().stream()),
            ready: false,
        };
        self.checked_content_witness(lease, witness)?;
        dlpack_consumer_stream(consumer_stream)?;
        self.steps
            .get_mut(&lease.token)
            .expect("validated witness step")
            .consumer_streams
            .insert(consumer_stream);
        let tensors = prepare_semantic_tensors(
            &self.provider,
            handoff
                .inputs
                .take()
                .expect("retained original verification inputs"),
        )?;
        let content = &mut self
            .steps
            .get_mut(&lease.token)
            .expect("validated witness step")
            .content[witness.index];
        let offset = content.verification_inputs.len();
        content.verification_inputs.extend(tensors);
        let actual = &content.verification_inputs[offset..];
        if actual.len() != content.tensors.len()
            || content
                .tensors
                .iter()
                .zip(actual)
                .any(|(expected, actual)| !same_tensor_content_owner(expected, actual))
        {
            return Err(publication_input_error("content verification must use the exact original tensor storage, layout and interval"));
        }
        self.enqueue_tensor_content(lease, witness, consumer_stream, true)
    }

    fn checked_content_witness(
        &self,
        lease: &SemanticPublishedLease,
        witness: &SemanticTensorContentWitness,
    ) -> Result<(), SemanticTransitionError> {
        let reader = self.checked_step(lease)?;
        if !Arc::ptr_eq(&self.publication_issuer, &witness.issuer)
            || witness.reader_token != lease.token
            || !Arc::ptr_eq(&reader.content_witnesses, &witness._witness)
            || witness.index >= reader.content.len()
        {
            return Err(publication_input_error(
                "content witness belongs to another parent or Session",
            ));
        }
        Ok(())
    }

    fn enqueue_tensor_content(
        &mut self,
        lease: &SemanticPublishedLease,
        witness: &SemanticTensorContentWitness,
        consumer_stream: u64,
        verify: bool,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_content_witness(lease, witness)?;
        lease.model_context_header()?;
        // Model witnesses retain the record authenticated by their own reader,
        // including after its release. A later publication must not replace that
        // baseline, nor force it to match the initial admission generation.
        self.enqueue_content_witness(witness, consumer_stream, verify)
    }

    // The handle is issued only by the original reader. A retained policy may
    // check it after publication without manufacturing a second acquired lease.
    fn guard_continuation_content(
        &mut self,
        binding: &TextBindingStorage,
    ) -> Result<(), SemanticTransitionError> {
        let witness = &binding._witness;
        let reader = self.steps.get(&witness.reader_token).ok_or_else(|| {
            publication_input_error("original continuation step has been released")
        })?;
        let original_parent = match &binding.parent {
            TextBindingParent::Published { .. } => reader.identity.is_some(),
            TextBindingParent::Prepared(inputs) => {
                reader
                    .inputs
                    .as_ref()
                    .is_some_and(|original| Arc::ptr_eq(original, inputs))
                    && reader
                        .prepared
                        .as_ref()
                        .is_some_and(|prepared| prepared.observed)
                    && self
                        .prepared_segment
                        .as_ref()
                        .is_some_and(|build| build.completed)
            }
        };
        if !Arc::ptr_eq(&self.publication_issuer, &witness.issuer)
            || !original_parent
            || !Arc::ptr_eq(&reader.content_witnesses, &witness._witness)
            || reader
                .content
                .get(witness.index)
                .is_none_or(|content| !matches!(content.seals, TensorContentSeals::Captured(_)))
        {
            return Err(publication_input_error(
                "continuation no longer owns its original captured content",
            ));
        }
        self.enqueue_content_witness(witness, binding.consumer_stream, true)
    }

    fn enqueue_content_witness(
        &mut self,
        witness: &SemanticTensorContentWitness,
        consumer_stream: u64,
        verify: bool,
    ) -> Result<(), SemanticTransitionError> {
        let execute = self
            .provider
            .device()
            .inner()
            .get_func(
                "xlog_semantic_transition",
                "semantic_tensor_content_witness",
            )
            .ok_or_else(|| runtime_error("kernel lookup", "tensor content witness unavailable"))?;
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|e| runtime_error("tensor content stream admission", e))?;
        let result = (|| {
            self.order_step_content_inputs(witness.reader_token, consumer_stream)?;
            let step_owner = &self.steps[&witness.reader_token];
            let retained = self
                .prepared_segment
                .as_ref()
                .is_some_and(|build| build.completed)
                && step_owner
                    .prepared
                    .as_ref()
                    .is_some_and(|prepared| prepared.observed);
            let custody = if retained {
                let bank = self.prepared_completed_parent_bank(witness.reader_token)?;
                let content = &self.steps[&witness.reader_token].content[witness.index];
                if matches!(&content.seals, TensorContentSeals::Model(seals)
                    if seals.prepared.as_ref().is_none_or(|source| source.bank != bank))
                {
                    return Err(publication_input_error(
                        "completed model witness requires its original executed branch bank",
                    ));
                }
                self.steps[&witness.reader_token]
                    .prepared
                    .as_ref()
                    .expect("checked prepared owner")
                    .replay_custody
                    .as_ref()
            } else {
                None
            };
            let content = &self.steps[&witness.reader_token].content[witness.index];
            content.enqueue_with_custody(
                &self.domain,
                &mut self.poisoned,
                &execute,
                verify,
                custody,
                retained,
            )?;
            self.order_content_consumers(consumer_stream)
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    fn ensure_step_inputs(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<Arc<PreparedStepInputs>, SemanticTransitionError> {
        self.checked_reader(lease)?;
        self.checked_step(lease)?;
        lease.model_context_header()?;
        if let Some(inputs) = &self.steps[&lease.token].inputs {
            return Ok(Arc::clone(inputs));
        }
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("step input preparation stream admission", error))?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let inputs = Arc::new(PreparedStepInputs::allocate(
            &self.provider,
            storage,
            self.readers[&lease.token].device.view(),
        )?);
        // Retain every output before the first upload or producer enqueue. A
        // partially initialized step remains owned by the poisoned Session.
        self.steps
            .get_mut(&lease.token)
            .expect("validated input step")
            .inputs = Some(Arc::clone(&inputs));
        let result = inputs
            .initialize(&self.provider)
            .and_then(|()| inputs.enqueue(&self.domain, &mut self.poisoned));
        if let Err(error) = result {
            self.poisoned = true;
            return Err(error);
        }
        Ok(inputs)
    }

    /// Export private step-owned physical source slots without host copying or rotation.
    pub fn published_source(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.export_publication_bank_field(lease, PublicationBankField::Source, consumer_stream)
    }

    /// Export the original acquired terminal flag as a read-only U64[1] view
    /// into the same private step inputs used by source and model context.
    /// The ordinary cold input preparation and retained consumer lifetime apply;
    /// no terminal value is inferred from source tokens or model metadata.
    pub fn published_terminal(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.export_publication_bank_field(lease, PublicationBankField::Terminal, consumer_stream)
    }

    /// Join retained acquisition metadata with fixed private prefix identity,
    /// extent, ring head and source views. Device acquisition supplies every
    /// value once; the step retains these inputs through the final consumer.
    pub fn published_model_context(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<SemanticModelContext, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        self.checked_reader(lease)?;
        let header = lease.model_context_header()?;
        let contract = self
            .publication
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?
            .contract_value;
        let prefix_range = lease
            .directory
            .iter()
            .find(|range| {
                range.role == SemanticStateRole::PrefixIdentity as u64 && range.index == 0
            })
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if prefix_range.length_bytes != 32 {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let prefix_identity =
            self.published_record(lease, SemanticStateRole::PrefixIdentity, 0, consumer_stream)?;
        let prefix_extent = self.export_publication_bank_field(
            lease,
            PublicationBankField::PrefixExtent,
            consumer_stream,
        )?;
        let ring_head = self.export_publication_bank_field(
            lease,
            PublicationBankField::RingHead,
            consumer_stream,
        )?;
        let source = self.published_source(lease, consumer_stream)?;
        Ok(SemanticModelContext {
            parent: lease.identity,
            descriptor_digest: header.descriptor_digest,
            numerical_state: (header.model_geometry_digest, header.model_numerical_digest),
            semantic_root: (
                header.semantic_owner,
                header.semantic_slot,
                header.semantic_generation,
                header.semantic_digest,
                header.semantic_extents,
            ),
            prefix: (prefix_identity, prefix_extent),
            ring_head,
            source,
            generations: (
                header.model_generation,
                header.neural_bank,
                header.neural_generation,
                header.cache_generation,
                header.authority_generation,
            ),
            topology_identity: contract.topology_identity,
            table_identity: contract.table_identity,
            capacities: (
                contract.prefix_capacity,
                contract.feedback_capacity,
                contract.max_position,
            ),
        })
    }

    /// Export the selected resident neural bank without the private step copy
    /// used by per-tensor late-backward exports. Full backing allocations occur
    /// once and retain the acquired reader, while the returned geometry names
    /// every typed view in roles 18..=25. Callers must keep these aliases
    /// read-only and release the parent only after every consumer stream joins.
    pub fn published_resident_model_memory(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<SemanticResidentModelMemory, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        self.checked_reader(lease)?;
        let header = lease.model_context_header()?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        storage.model_memory.validate(&storage.layouts)?;
        if storage.model_slots.len() != storage.model_memory.allocation_bytes.len() {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let keys = lease
            .directory
            .iter()
            .filter(|range| matches!(range.role, 18..=25))
            .map(|range| {
                SemanticStateRole::from_code(range.role)
                    .map(|role| (role, range.index))
                    .ok_or(SemanticTransitionError::ObservationMismatch)
            })
            .collect::<Result<Vec<_>, _>>()?;
        if keys.len() != storage.model_memory.views.len() {
            return Err(publication_input_error(
                "resident model memory requires the complete selected model roster",
            ));
        }
        self.guard_published_content(lease, &keys, consumer_stream)?;

        let mut allocations = Vec::with_capacity(storage.model_slots.len());
        for (allocation_index, (&bytes, slots)) in storage
            .model_memory
            .allocation_bytes
            .iter()
            .zip(&storage.model_slots)
            .enumerate()
        {
            let mut selected_slot = None;
            for range in lease
                .directory
                .iter()
                .filter(|range| matches!(range.role, 18..=25))
            {
                let (owner, _) = storage.model_memory.location(range.role, range.index)?;
                if owner == allocation_index
                    && selected_slot
                        .replace(range.storage_slot as usize)
                        .is_some_and(|prior| prior != range.storage_slot as usize)
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
            }
            let slot = selected_slot.unwrap_or(slots[(lease.identity.word & 1) as usize]);
            if !slots.contains(&slot) {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let allocation = storage
                .allocations
                .get(slot)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            if allocation.len() as u64 != bytes {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let view = allocation.view();
            let provenance = view.allocation_provenance().ok_or_else(|| {
                publication_input_error("resident model backing has no native allocation owner")
            })?;
            let extent =
                i64::try_from(bytes).map_err(|_| SemanticTransitionError::ObservationMismatch)?;
            let tensor = self.export_reader_view(
                lease,
                view,
                vec![extent],
                vec![1],
                (1, 8),
                consumer_stream,
            )?;
            allocations.push((provenance, tensor));
        }
        let views = storage
            .model_memory
            .views
            .iter()
            .cloned()
            .map(|view| {
                let layout = storage
                    .layouts
                    .get(&(view.role, view.index))
                    .copied()
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                Ok((view, layout))
            })
            .collect::<Result<Vec<_>, SemanticTransitionError>>()?;
        Ok(SemanticResidentModelMemory {
            parent: lease.identity,
            generations: (
                header.model_generation,
                header.neural_bank,
                header.neural_generation,
            ),
            numerical_state: (header.model_geometry_digest, header.model_numerical_digest),
            allocations,
            storages: storage.model_memory.storages.clone(),
            views,
        })
    }

    /// Export this acquired parent's prefix storage as U64[capacity, 8]. Columns
    /// follow SemanticTextSlot exactly, including source/generated provenance and
    /// its native ledger index. Only [0, prefix_extent) is committed, including
    /// the legal empty prefix; unused capacity must not be consumed as content.
    /// The export neither acquires again nor copies rows to host.
    /// The managed owner retains the same reader and append-only prefix storage.
    /// Consumers must not modify this sealed view and must join their final use
    /// through release, just as for published_tensor.
    pub fn published_prefix(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<(SemanticPublishedIdentity, DlpackManagedTensor), SemanticTransitionError> {
        self.checked_reader(lease)?;
        let range = *lease
            .directory
            .iter()
            .find(|range| range.role == SemanticStateRole::PrefixSource as u64 && range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if range.logical_end != lease.header.prefix_extent {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let capacity = self
            .publication
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?
            .contract_value
            .prefix_capacity;
        let layout = committed_prefix_layout(&range, capacity)?;
        let tensor = self.export_publication_range(lease, range, layout, consumer_stream)?;
        Ok((lease.identity, tensor))
    }

    /// Read RNG coordinates from the actual parent of the pending continuation.
    /// The application cannot supply a replacement stream or proposal identity.
    pub fn continuation_rng(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<SemanticRngBinding, SemanticTransitionError> {
        self.checked_reader(lease)?;
        if self.continuation_base != Some(lease.identity.word)
            || self
                .admitted_transition
                .is_none_or(|(token, word, _)| token != lease.token || word != lease.identity.word)
        {
            return Err(publication_input_error(
                "execution requires this exact acquired reader's admitted continuation",
            ));
        }
        lease.header.rng_binding()
    }

    /// Original coordinates for policy snapshot admission, before continuation
    /// binding. This does not authorize capture, execution or a draw.
    #[cfg(feature = "semantic-policy")]
    pub fn admitted_policy_rng(
        &self,
        lease: &SemanticPublishedLease,
    ) -> Result<SemanticRngBinding, SemanticTransitionError> {
        self.checked_reader(lease)?;
        if self.admitted_transition
            != Some((
                lease.token,
                lease.identity.word,
                SemanticTransitionKind::Proposal,
            ))
        {
            return Err(publication_input_error(
                "policy snapshot requires this exact acquired reader's admitted proposal",
            ));
        }
        lease.header.rng_binding()
    }

    fn read_published_control_record(
        &mut self,
        lease: &SemanticPublishedLease,
        role: u64,
    ) -> Result<PublicationMaterialRange, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let range = *lease
            .directory
            .iter()
            .find(|range| range.role == role && range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let allocation = storage
            .allocations
            .get(range.storage_slot as usize)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let begin = usize::try_from(range.offset_bytes)
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let end = usize::try_from(range.length_bytes)
            .ok()
            .and_then(|length| begin.checked_add(length))
            .filter(|&end| end <= allocation.len())
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let bytes = self.publication_read(allocation.view().slice(begin..end))?;
        let material = PublicationMaterialRange {
            range,
            capacity: allocation.len() - begin,
            bytes,
        };
        if material.original_record_digest() != range.digest {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(material)
    }

    /// Verify a durable receiver receipt against the actual current FINAL
    /// intent, then append it through the publication word's sole CAS. This is
    /// cold external-effect control, not a model or semantic transition.
    pub fn acknowledge_delivery(
        &mut self,
        lease: &SemanticPublishedLease,
        receipt: &[u8],
        recipient_id: Identity256,
        verification_key: &[u8; 32],
        expected_effect: &[u8],
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.checked_reader(lease)?;
        if self.pending || self.admitted_transition.is_some() || self.continuation_base.is_some() {
            return Err(publication_input_error(
                "delivery acknowledgement cannot overlap a transition",
            ));
        }
        if lease.header.terminal != 2
            || receipt.len() < 169
            || verification_key.iter().all(|&byte| byte == 0)
        {
            return Err(publication_input_error(
                "delivery acknowledgement requires a FINAL parent and trusted receipt",
            ));
        }
        let entries = self.read_published_control_record(lease, 30)?;
        let payload = self.read_published_control_record(lease, 31)?;
        let acknowledgements = self.read_published_control_record(lease, 32)?;
        let intents = output_intents_from_ranges(&entries, &payload)?;
        let acknowledged =
            acknowledgement_receipts(&acknowledgements.bytes, acknowledgements.capacity)?;
        let stable_identity =
            Identity256::from_bytes(receipt[25..57].try_into().expect("checked receipt extent"));
        let intent = intents
            .iter()
            .find(|intent| intent.stable_identity == stable_identity)
            .ok_or_else(|| {
                publication_input_error("delivery receipt has no native FINAL intent")
            })?;
        if expected_effect.is_empty() || intent.effect.as_slice() != expected_effect {
            return Err(publication_input_error(
                "native FINAL effect differs from the bound receiver",
            ));
        }
        let receipt_digest =
            verify_delivery_receipt(receipt, intent, recipient_id, verification_key)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let current = self.publication_read(storage.control.view())?[0];
        if current.instance != lease.identity.instance || current.word != lease.identity.word {
            return Err(publication_input_error(
                "delivery acknowledgement requires the current acquired FINAL parent",
            ));
        }
        if let Some((_, previous)) = acknowledged
            .iter()
            .find(|(identity, _)| *identity == stable_identity)
        {
            if previous == receipt {
                return Ok(lease.identity);
            }
            return Err(publication_input_error(
                "native intent was acknowledged with a different receipt",
            ));
        }
        if lease.header.fuel == 0 {
            return Err(publication_input_error(
                "FINAL parent has no reserved acknowledgement fuel",
            ));
        }
        let receipt_device = allocate_publication::<u8>(&self.provider, receipt.len())?;
        upload_publication(&self.provider, receipt, &receipt_device)?;
        let input_device = allocate_publication::<PublicationDeliveryInput>(&self.provider, 1)?;
        upload_publication(
            &self.provider,
            &[PublicationDeliveryInput {
                lease: self.readers[&lease.token].device.device_ptr_value(),
                receipt: receipt_device.device_ptr_value(),
                receipt_len: receipt.len() as u64,
                recipient_id,
                receipt_digest,
            }],
            &input_device,
        )?;
        let mut descriptor = self.descriptor();
        descriptor.publication = PublicationCommand {
            control: storage.control.device_ptr_value(),
            lease: input_device.device_ptr_value(),
            operation: 6,
        };
        let mut recorder = self.kernel_recorder();
        recorder.read(&receipt_device);
        recorder.read(&input_device);
        recorder.read(&self.readers[&lease.token].device);
        let execute = self.execute.clone();
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |stream| {
            // SAFETY: the strict recorder retains the acquired lease, exact
            // receipt and command until the native CAS completes.
            unsafe {
                execute.launch_in(
                    stream,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (256, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (descriptor,),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "delivery acknowledgement publication",
            CudaStream::synchronize,
        )?;
        let control = self.publication_read(storage.control.view())?[0];
        if control.refusal != 0 {
            return Err(SemanticTransitionError::PublicationRefused {
                status: control.refusal,
            });
        }
        let header = self.read_publication_header((control.word & 1) as usize)?;
        let expected_word = ((lease.identity.word >> 1) + 1) << 1 | ((lease.identity.word & 1) ^ 1);
        if control.word != expected_word
            || header.publication_word != control.word
            || header.terminal != 2
            || header.fuel + 1 != lease.header.fuel
            || header.instance != lease.identity.instance
        {
            self.poisoned = true;
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(SemanticPublishedIdentity {
            instance: header.instance,
            word: header.publication_word,
            logical_digest: header.logical_digest,
            state_digest: header.state_digest,
        })
    }

    /// A FINAL acquired bank must contain its actual native terminal intent.
    /// This readiness check does not deliver an effect or issue use authority.
    pub fn admit_external_activation(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<(), SemanticTransitionError> {
        self.checked_reader(lease)?;
        if lease.header.terminal != 2 {
            return Err(publication_input_error(
                "external activation requires a genuinely published FINAL parent",
            ));
        }
        if lease.header.fuel == 0 {
            return Err(publication_input_error(
                "FINAL parent has no reserved fuel for durable delivery acknowledgement",
            ));
        }
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let range = lease
            .directory
            .iter()
            .find(|range| range.role == 30)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let payload = lease
            .directory
            .iter()
            .find(|range| range.role == 31)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let owner = storage
            .allocations
            .get(range.storage_slot as usize)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if range.offset_bytes != 0
            || range.length_bytes < size_of::<IntentQueueHeader>() as u64
            || range.length_bytes > owner.len() as u64
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        // SAFETY: checked header range is integral, aligned and initialized by
        // the acquired sealed directory's actual native queue owner.
        let header_view = unsafe {
            owner
                .view()
                .slice(..size_of::<IntentQueueHeader>())
                .cast::<IntentQueueHeader>()
        }
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let header = self.publication_read(header_view)?[0];
        if header.abi != 1
            || header.count == 0
            || header.count > header.capacity
            || header
                .count
                .checked_mul(size_of::<IntentEntry>() as u64)
                .and_then(|n| n.checked_add(size_of::<IntentQueueHeader>() as u64))
                != Some(range.length_bytes)
            || header.payload_used_bytes != payload.length_bytes
            || header.payload_used_bytes > header.payload_capacity_bytes
            || header.effect_length_bytes == 0
            || header
                .effect_offset_bytes
                .checked_add(header.effect_length_bytes)
                .is_none_or(|n| n > header.payload_used_bytes)
        {
            return Err(publication_input_error(
                "FINAL bank has no complete native terminal intent queue",
            ));
        }
        let begin =
            size_of::<IntentQueueHeader>() + (header.count as usize - 1) * size_of::<IntentEntry>();
        // SAFETY: exact final entry extent follows from the checked queue count.
        let entry_view = unsafe {
            owner
                .view()
                .slice(begin..begin + size_of::<IntentEntry>())
                .cast::<IntentEntry>()
        }
        .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let entry = self.publication_read(entry_view)?[0];
        if entry.audit_instance != lease.identity.instance
            || entry.audit_epoch != lease.identity.word >> 1
            || entry.result_logical != lease.identity.logical_digest
            || entry.chain != header.chain_head
            || entry.payload_len < 8
            || entry
                .payload_offset
                .checked_add(entry.payload_len)
                .is_none_or(|n| n > header.payload_used_bytes)
            || entry.stable_identity == Identity256::default()
            || entry.effect_digest == Identity256::default()
        {
            return Err(publication_input_error(
                "terminal intent is not the actual final effect of this acquired publication",
            ));
        }
        let current = self.publication_read(storage.control.view())?[0];
        if current.instance != lease.identity.instance || current.word != lease.identity.word {
            return Err(publication_input_error(
                "external activation requires the current acquired FINAL parent",
            ));
        }
        let entries = self.read_published_control_record(lease, 30)?;
        let payload = self.read_published_control_record(lease, 31)?;
        let acknowledgements = self.read_published_control_record(lease, 32)?;
        let intents = output_intents_from_ranges(&entries, &payload)?;
        let acknowledged =
            acknowledgement_receipts(&acknowledgements.bytes, acknowledgements.capacity)?;
        if intents.iter().all(|intent| {
            acknowledged
                .iter()
                .any(|(identity, _)| *identity == intent.stable_identity)
        }) {
            return Err(publication_input_error(
                "FINAL publication has no unacknowledged delivery intent",
            ));
        }
        Ok(())
    }

    /// Export the cold physical-capacity tensor shape, retaining its original
    /// sealed logical range. Unused rows are not content. Shared prefix caches
    /// retain the reader; private input caches retain their original step.
    pub fn published_tensor(
        &mut self,
        lease: &SemanticPublishedLease,
        role: SemanticStateRole,
        index: u64,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        let (range, layout) = self.published_tensor_layout(lease, role, index)?;
        if matches!(role as u64, 18..=25 | 51..=54) {
            self.guard_published_content(lease, &[(role, index)], consumer_stream)?;
        }
        self.export_publication_range(lease, range, layout, consumer_stream)
    }

    /// Select the exact published training view from the cold resident arena.
    /// The host supplies neither an ordinal nor an identity: both the cursor and
    /// RNG coordinates come from this acquired publication, while CUDA verifies
    /// the complete role-29 bytes before exposing fixed output ports.
    pub fn select_training_view(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<SemanticSelectedTrainingView, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let arena = Arc::clone(
            self.training_views
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let range = *lease
            .directory
            .iter()
            .find(|range| range.role == SemanticStateRole::TrainingView as u64 && range.index == 0)
            .ok_or_else(|| publication_input_error("acquired training-view range is absent"))?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let allocation = storage
            .allocations
            .get(
                usize::try_from(range.storage_slot)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
            )
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let begin = usize::try_from(range.offset_bytes)
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let length = usize::try_from(range.length_bytes)
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let end = begin
            .checked_add(length)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let selected = allocation
            .view()
            .try_slice(begin..end)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let result = arena.enqueue_selection(
            selected,
            lease.header.training_cursor,
            lease.header.training_rng,
            self.training_origins.clone(),
        );
        if matches!(
            &result,
            Err(SemanticTransitionError::Runtime {
                operation: "training-view device selection" | "training-view launch commit",
                ..
            })
        ) {
            self.poisoned = true;
        }
        result
    }

    /// Allocation origin and complete backing bytes of the exact view exported
    /// by `published_tensor`, retaining that view's reader/step access grant.
    /// Exported capacity is not evidence that unused contents are model inputs.
    pub fn published_tensor_allocation(
        &mut self,
        lease: &SemanticPublishedLease,
        role: SemanticStateRole,
        index: u64,
        consumer_stream: u64,
    ) -> Result<(DeviceAllocationProvenance, DlpackManagedTensor), SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        let (range, layout) = self.published_tensor_layout(lease, role, index)?;
        if matches!(role as u64, 18..=25 | 51..=54) {
            self.guard_published_content(lease, &[(role, index)], consumer_stream)?;
        }
        let view = self.publication_tensor_view(lease, range, layout)?;
        let provenance = view.allocation_provenance().ok_or_else(|| {
            publication_input_error("published tensor has no complete native allocation owner")
        })?;
        let allocation = view
            .allocation_view()
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let bytes = i64::try_from(allocation.len())
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let tensor = self.export_publication_tensor_view(
            lease,
            range.role,
            allocation,
            vec![bytes],
            vec![1],
            (1, 8),
            consumer_stream,
        )?;
        Ok((provenance, tensor))
    }

    fn published_tensor_layout(
        &self,
        lease: &SemanticPublishedLease,
        role: SemanticStateRole,
        index: u64,
    ) -> Result<(PublicationRange, SemanticTensorLayout), SemanticTransitionError> {
        self.checked_reader(lease)?;
        let storage = self
            .publication
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        let layout = *storage
            .layouts
            .get(&(role as u64, index))
            .ok_or_else(|| publication_input_error("acquired role has no model tensor layout"))?;
        let range = *lease
            .directory
            .iter()
            .find(|range| range.role == role as u64 && range.index == index)
            .ok_or_else(|| publication_input_error("acquired tensor range is absent"))?;
        Ok((range, layout))
    }

    /// Read the map from this acquired bank's sealed record, not a later pending
    /// invocation. Reading these small identity records never reads tensor values.
    pub fn published_active_rows(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<SemanticActiveRows, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let bytes = self.read_published_record_bytes(lease, SemanticStateRole::TensorLayout)?;
        let (_, layouts, active) = decode_tensor_table(&bytes)?;
        let storage = self
            .publication
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        if layouts != storage.layouts.values().copied().collect::<Vec<_>>()
            || active.rows.len() as u64 > 32 + storage.contract_value.feedback_capacity
            || lease
                .directory
                .iter()
                .filter(|range| matches!(range.role, 51..=54))
                .any(|range| {
                    range.logical_begin != 0
                        || range.logical_end != active.rows.len() as u64
                        || (active.rows.is_empty() != (range.length_bytes == 0))
                })
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(active)
    }

    /// Cold read of the original model contribution from this acquired parent.
    /// The application freezes external writers; registered consumer prefixes
    /// are joined before reading and verifying the original sealed bytes.
    /// This is never a host query inside a resident reasoning loop.
    pub fn published_model_numerical_mode(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        self.ensure_quiescent()?;
        let streams = self
            .checked_reader(lease)?
            .consumer_streams
            .iter()
            .chain(&self.checked_step(lease)?.consumer_streams)
            .copied()
            .collect::<BTreeSet<_>>()
            .into_iter()
            .collect::<Vec<_>>();
        self.complete_step_consumers(lease, &streams)?;
        let record = self.read_published_material_range(lease, 43, 0)?;
        if record.original_record_digest() != record.range.digest {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let table =
            self.read_published_material_range(lease, SemanticStateRole::TensorLayout as u64, 0)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let contract = self.publication_read(storage.contract.view())?[0];
        if publication_abi_bytes(&[contract]) != publication_abi_bytes(&[storage.contract_value]) {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let counts = self.publication_read(storage.role_counts.view())?;
        let mut role_counts = [0; 55];
        for (index, count) in counts.iter().enumerate() {
            if count.role != index as u64 + 1 {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            role_counts[index] = count.count;
        }
        let terminals = self.publication_read(storage.terminals.view())?;
        let capacities = lease
            .directory
            .iter()
            .map(|range| {
                let allocation = usize::try_from(range.storage_slot)
                    .ok()
                    .and_then(|slot| storage.allocations.get(slot))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let capacity = usize::try_from(range.offset_bytes)
                    .ok()
                    .and_then(|offset| allocation.len().checked_sub(offset))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                Ok((range.role, range.index, capacity))
            })
            .collect::<Result<Vec<_>, SemanticTransitionError>>()?;
        Ok(verified_runtime_model_mode(
            &record.bytes,
            contract,
            &role_counts,
            &terminals,
            &storage.layouts,
            &capacities,
            &table,
            &storage.model_memory,
        )?
        .to_vec())
    }

    /// Cold export of the complete native material reachable from this acquired
    /// parent. The bytes carry content, not a use grant or publication authority.
    /// The canonical execution carrier must bind them to its original invocation.
    pub fn published_state_material(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        self.ensure_quiescent()?;
        self.checked_reader(lease)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let bank = self.read_published_bank(lease)?;
        let graph = self
            .graph
            .export_transition_root_parts(
                bank.header.semantic_owner,
                bank.header.semantic_slot,
                bank.header.semantic_generation,
            )
            .map_err(SemanticTransitionError::Semantic)?;
        let counts = self.publication_read(storage.role_counts.view())?;
        let mut role_counts = [0; 55];
        for (index, count) in counts.iter().enumerate() {
            if count.role != index as u64 + 1 {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            role_counts[index] = count.count;
        }
        let terminals = if storage.terminals.is_empty() {
            Vec::new()
        } else {
            self.publication_read(storage.terminals.view())?
        };
        let mut ranges = Vec::with_capacity(lease.directory.len());
        let mut model_allocations = Vec::with_capacity(storage.model_slots.len());
        for (allocation_index, slots) in storage.model_slots.iter().enumerate() {
            let mut selected_slot = None;
            for range in lease
                .directory
                .iter()
                .filter(|range| matches!(range.role, 18..=25))
            {
                let (owner, _) = storage.model_memory.location(range.role, range.index)?;
                if owner == allocation_index
                    && selected_slot
                        .replace(range.storage_slot as usize)
                        .is_some_and(|prior| prior != range.storage_slot as usize)
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
            }
            let slot = selected_slot.unwrap_or(slots[(lease.identity.word & 1) as usize]);
            if !slots.contains(&slot) {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            let allocation = &storage.allocations[slot];
            model_allocations.push(if allocation.is_empty() {
                Vec::new()
            } else {
                self.publication_read(allocation.view())?
            });
        }
        for range in &lease.directory {
            if matches!(range.role, 18..=25) {
                let (allocation, offset) =
                    storage.model_memory.location(range.role, range.index)?;
                let end = usize::try_from(range.length_bytes)
                    .ok()
                    .and_then(|bytes| offset.checked_add(bytes))
                    .ok_or(SemanticTransitionError::ObservationMismatch)?;
                let bytes = model_allocations[allocation]
                    .get(offset..end)
                    .ok_or(SemanticTransitionError::ObservationMismatch)?
                    .to_vec();
                ranges.push(PublicationMaterialRange {
                    range: *range,
                    capacity: model_allocations[allocation].len() - offset,
                    bytes,
                });
            } else {
                ranges.push(self.read_published_material_range(lease, range.role, range.index)?);
            }
        }
        let mut contract = storage.contract_value;
        // Device addresses and owner handles are relocated from fresh actual
        // allocations. They can never be imported as executable pointers.
        contract.terminal_tokens = 0;
        contract.role_counts = 0;
        contract.semantic_owner = 0;
        PublicationMaterial {
            bank,
            contract,
            role_counts,
            terminals,
            layouts: storage.layouts.clone(),
            model_memory: storage.model_memory.clone(),
            model_allocations,
            ranges,
            graph,
            learning_phases: self.learning_phases.clone(),
        }
        .encode()
    }

    /// Cold export of native evidence from two genuinely held adjacent
    /// publications. Only the successor identity and its six publication-only
    /// records enter the evidence; the successor's full state is not exported.
    /// The application must freeze further writers and register all consumer
    /// streams before this call. Both later release rosters must include one.
    pub fn published_replay_evidence(
        &mut self,
        predecessor: &SemanticPublishedLease,
        successor: &SemanticPublishedLease,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        self.guard_replay_publications(predecessor, successor)?;
        let predecessor =
            PublicationMaterial::decode(&self.published_state_material(predecessor)?)?;
        self.read_replay_evidence(&predecessor, successor)?.encode()
    }

    /// Cold export of the original authority envelope and actual successor
    /// continuation decision from held adjacent publications. The execution
    /// carrier stores this as its reconstruction provenance root, not evidence
    /// of current rights and not a second copy of the complete predecessor.
    /// Further writers must be frozen and every consumer stream registered;
    /// both later release rosters must include the guard's stream one.
    pub fn published_replay_provenance(
        &mut self,
        predecessor: &SemanticPublishedLease,
        successor: &SemanticPublishedLease,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        self.guard_replay_publications(predecessor, successor)?;
        let identity = predecessor.identity;
        let predecessor =
            PublicationMaterial::decode(&self.published_state_material(predecessor)?)?;
        self.read_replay_evidence(&predecessor, successor)?;
        let authority = predecessor
            .ranges
            .iter()
            .find(|item| item.range.role == 38 && item.range.index == 0)
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .clone();
        let decision = self.read_published_material_range(successor, 39, 0)?;
        let provenance = PublicationReplayProvenance {
            predecessor: identity,
            authority,
            decision,
        };
        provenance.validate(&predecessor)?;
        provenance.encode()
    }

    /// Restore already-decoded complete predecessor material through the sole
    /// native cold restoration path. Current use authority remains external.
    pub fn restore_replay_material(
        &mut self,
        material: &SemanticReplayMaterial,
    ) -> Result<SemanticPublishedIdentity, SemanticTransitionError> {
        self.restore_state_material(&material.predecessor.encode()?)
    }

    /// Compare a genuine rerun with the expected complete logical/state hashes
    /// and normalized publication records. Runtime instance/word coordinates
    /// differ after restoration and are checked as new lineage, not byte-equal.
    /// This cold check neither issues a use grant nor proves historical origin.
    /// It guards every actual range of both held readers before cold readback;
    /// cached seals alone cannot detect writes through shared tensor aliases.
    /// The method owns consumer stream one for both readers. Their later release
    /// rosters must include one as well as every application consumer stream.
    pub fn verify_replay_publication(
        &mut self,
        material: &SemanticReplayMaterial,
        predecessor: &SemanticPublishedLease,
        successor: &SemanticPublishedLease,
    ) -> Result<(), SemanticTransitionError> {
        self.guard_replay_publications(predecessor, successor)?;
        // The following ordinary cold reads wait for both guards on the native
        // stream and propagate a fatal integrity error before accepting bytes.
        let actual_predecessor =
            PublicationMaterial::decode(&self.published_state_material(predecessor)?)?;
        let header = actual_predecessor.bank.header;
        let expected = material.predecessor_identity();
        if header.instance == expected.instance
            || header.recovered_instance != expected.instance
            || header.publication_word != 0
            || header.logical_digest != expected.logical_digest
            || header.state_digest != expected.state_digest
        {
            return Err(publication_input_error(
                "replay comparison requires the freshly restored complete predecessor",
            ));
        }
        let actual = self.read_replay_evidence(&actual_predecessor, successor)?;
        if actual.successor.logical_digest != material.evidence.successor.logical_digest
            || actual.successor.state_digest != material.evidence.successor.state_digest
        {
            return Err(publication_input_error(
                "genuine replay successor differs from the expected complete native state",
            ));
        }
        for (actual, expected) in actual.ranges.iter().zip(&material.evidence.ranges) {
            if actual.logical_record_digest()? != expected.logical_record_digest()? {
                return Err(publication_input_error(
                    "genuine replay differs from the expected normalized publication records",
                ));
            }
        }
        Ok(())
    }

    // Fence all registered writer/consumer prefixes before hashing either bank.
    // This does not retire the original graph's aliases or witnesses and cannot
    // fence future writes; the controlling application freezes those separately.
    fn guard_replay_publications(
        &mut self,
        predecessor: &SemanticPublishedLease,
        successor: &SemanticPublishedLease,
    ) -> Result<(), SemanticTransitionError> {
        for lease in [predecessor, successor] {
            let streams = self
                .checked_reader(lease)?
                .consumer_streams
                .iter()
                .chain(&self.checked_step(lease)?.consumer_streams)
                .copied()
                .collect::<BTreeSet<_>>()
                .into_iter()
                .collect::<Vec<_>>();
            self.complete_step_consumers(lease, &streams)?;
        }
        let predecessor_ranges = self.published_range_keys(predecessor)?;
        let successor_ranges = self.published_range_keys(successor)?;
        self.guard_published_content(predecessor, &predecessor_ranges, 1)?;
        self.guard_published_content(successor, &successor_ranges, 1)
    }

    fn read_replay_evidence(
        &mut self,
        predecessor: &PublicationMaterial,
        successor: &SemanticPublishedLease,
    ) -> Result<PublicationReplayEvidence, SemanticTransitionError> {
        let bank = self.read_published_bank(successor)?;
        let mut ranges = Vec::with_capacity(REPLAY_EVIDENCE_ROLES.len());
        for role in REPLAY_EVIDENCE_ROLES {
            ranges.push(self.read_published_material_range(successor, role, 0)?);
        }
        let evidence = PublicationReplayEvidence {
            successor: successor.identity,
            ranges,
        };
        let coverage = self.read_published_material_range(successor, 14, 0)?;
        let codebook = self.read_published_material_range(successor, 48, 0)?;
        evidence.validate_observed(predecessor, &bank, &coverage, &codebook)?;
        Ok(evidence)
    }

    fn read_published_bank(
        &mut self,
        lease: &SemanticPublishedLease,
    ) -> Result<PublicationBank, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let bank =
            self.publication_read(storage.banks[(lease.identity.word & 1) as usize].view())?[0];
        if publication_abi_bytes(&[bank.header]) != publication_abi_bytes(&[lease.header])
            || publication_abi_bytes(&bank.source) != publication_abi_bytes(&lease.source)
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(bank)
    }

    fn read_published_material_range(
        &mut self,
        lease: &SemanticPublishedLease,
        role: u64,
        index: u64,
    ) -> Result<PublicationMaterialRange, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let range = lease
            .directory
            .iter()
            .find(|range| (range.role, range.index) == (role, index))
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let owner = storage
            .allocations
            .get(
                usize::try_from(range.storage_slot)
                    .map_err(|_| SemanticTransitionError::ObservationMismatch)?,
            )
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let begin = usize::try_from(range.offset_bytes)
            .map_err(|_| SemanticTransitionError::ObservationMismatch)?;
        let end = usize::try_from(range.length_bytes)
            .ok()
            .and_then(|n| begin.checked_add(n))
            .filter(|&end| end <= owner.len())
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if range.generation != 1 {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let bytes = if begin == end {
            Vec::new()
        } else {
            self.publication_read(owner.view().slice(begin..end))?
        };
        Ok(PublicationMaterialRange {
            range: *range,
            capacity: owner.len() - begin,
            bytes,
        })
    }

    fn read_published_record_bytes(
        &mut self,
        lease: &SemanticPublishedLease,
        role: SemanticStateRole,
    ) -> Result<Vec<u8>, SemanticTransitionError> {
        Ok(self
            .read_published_material_range(lease, role as u64, 0)?
            .bytes)
    }

    /// Export the actual bytes of one acquired non-tensor owner, including native
    /// raw feedback. This performs no host tensor-value read or numeric cast.
    pub fn published_record(
        &mut self,
        lease: &SemanticPublishedLease,
        role: SemanticStateRole,
        index: u64,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        self.checked_reader(lease)?;
        if is_tensor_role(role as u64) {
            return Err(publication_input_error(
                "tensor roles require their exact model layout export",
            ));
        }
        let range = *lease
            .directory
            .iter()
            .find(|range| range.role == role as u64 && range.index == index)
            .ok_or_else(|| publication_input_error("acquired record range is absent"))?;
        self.export_publication_range(
            lease,
            range,
            publication_record_layout(&range),
            consumer_stream,
        )
    }

    /// Encode the exact acquired raw slots and current lineage on the device,
    /// without packing or status/validity readback. The projection kernel traps
    /// on invalid provenance before the consumer event can become ready.
    /// All six outputs receive their original private content seals before
    /// export. Later tensor-content capture verifies those seals, not a new
    /// baseline made from potentially modified consumer aliases.
    pub fn published_feedback(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<SemanticFeedback, SemanticTransitionError> {
        self.checked_reader(lease)?;
        dlpack_consumer_stream(consumer_stream)?;
        if self
            .admitted_transition
            .is_none_or(|(token, word, _)| token != lease.token || word != lease.identity.word)
        {
            return Err(publication_input_error(
                "feedback encoding requires this acquired parent's admitted segment",
            ));
        }
        // Keep the complete ordinary call outside capture, including the gaps
        // between allocation, producer launches, original seals and exports.
        // The private prepared enqueue remains usable by the segment builder.
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("feedback stream admission", error))?;
        let schema = SemanticFeedbackSchema::new(self.feedback_statement_bytes()?)?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let descriptor = self.descriptor();
        let buffers = FeedbackBuffers::allocate(
            &self.provider,
            schema,
            storage.contract_value.feedback_capacity,
            descriptor.arena[4],
        )?;
        let schema = buffers.schema.clone();
        let slots = buffers.slots;
        let support_capacity = buffers.support_capacity;
        let offset_cells = buffers.support_offsets.len();
        // Install the permanent step owner before any kernel or export can
        // enqueue. A later error or unwind cannot replace/drop unfinished
        // outputs through a subsequent feedback call.
        let reader = self
            .steps
            .get_mut(&lease.token)
            .expect("validated feedback step");
        let output_index = reader.feedback.len();
        reader.feedback.push(buffers);
        let result = (|| {
            let reader = self
                .readers
                .get(&lease.token)
                .expect("validated native reader");
            let buffers = &self.steps[&lease.token].feedback[output_index];
            buffers.enqueue(
                &self.domain,
                &mut self.poisoned,
                &self.graph,
                &storage,
                &self
                    .task
                    .as_ref()
                    .ok_or(SemanticTransitionError::InvalidTaskBank)?
                    .1,
                &reader.device,
                descriptor,
            )?;
            // SAFETY: f32 has a padding-free byte representation. The returned
            // view retains the complete original tracked feature allocation.
            let features = unsafe { buffers.features.view().cast::<u8>() }
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let device_validity = buffers.validity.view();
            let queries = buffers.query_receipts.view();
            let originals = buffers.original_statements.view();
            let offsets = buffers.support_offsets.view();
            let support_rows = buffers.supports.view();
            let features = self.export_step_view(
                lease,
                features,
                vec![slots as i64, schema.feature_width as i64],
                vec![schema.feature_width as i64, 1],
                (2, 32),
                consumer_stream,
            )?;
            let device_validity = self.export_step_view(
                lease,
                device_validity,
                vec![slots as i64],
                vec![1],
                (6, 8),
                consumer_stream,
            )?;
            let mut export_words =
                |view: DeviceMemoryView<u64>, shape: Vec<i64>, strides: Vec<i64>| {
                    // SAFETY: u64 has no padding; the complete tracked owner stays
                    // attached to each byte view and acquired-reader export.
                    let bytes = unsafe { view.cast::<u8>() }
                        .ok_or(SemanticTransitionError::ObservationMismatch)?;
                    self.export_step_view(lease, bytes, shape, strides, (1, 64), consumer_stream)
                };
            let query_receipts = export_words(queries, vec![slots as i64, 42], vec![42, 1])?;
            let original_statements = export_words(originals, vec![slots as i64], vec![1])?;
            let support_offsets = export_words(offsets, vec![offset_cells as i64], vec![1])?;
            let supports =
                export_words(support_rows, vec![support_capacity as i64, 12], vec![12, 1])?;
            Ok(SemanticFeedback {
                parent: lease.identity,
                schema,
                features,
                device_validity,
                query_receipts,
                original_statements,
                support_offsets,
                supports,
            })
        })();
        if result.is_err() {
            self.poisoned = true;
        }
        result
    }

    fn publication_tensor_view(
        &mut self,
        lease: &SemanticPublishedLease,
        range: PublicationRange,
        layout: SemanticTensorLayout,
    ) -> Result<DeviceMemoryView<u8>, SemanticTransitionError> {
        self.checked_reader(lease)?;
        let view = if matches!(range.role, 1 | 3..=13 | 18..=25) {
            let inputs = self.ensure_step_inputs(lease)?;
            let view = inputs
                .views
                .get((lease.header.publication_word & 1) as usize)
                .expect("two publication input banks")
                .get(&(range.role, range.index))
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            let local = PublicationRange {
                offset_bytes: 0,
                ..range
            };
            view.slice(publication_export_span(&local, &layout, view.len())?)
        } else {
            let storage = Arc::clone(
                self.publication
                    .as_ref()
                    .ok_or(SemanticTransitionError::NotBound)?,
            );
            let allocation = storage
                .allocations
                .get(range.storage_slot as usize)
                .ok_or(SemanticTransitionError::ObservationMismatch)?;
            allocation
                .view()
                .slice(publication_export_span(&range, &layout, allocation.len())?)
        };
        Ok(view)
    }

    fn export_publication_range(
        &mut self,
        lease: &SemanticPublishedLease,
        range: PublicationRange,
        layout: SemanticTensorLayout,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        let view = self.publication_tensor_view(lease, range, layout)?;
        let shape = layout.dimensions[..layout.rank as usize]
            .iter()
            .map(|&n| {
                i64::try_from(n)
                    .map_err(|_| publication_input_error("DLPack shape exceeds signed extent"))
            })
            .collect::<Result<Vec<_>, _>>()?;
        let strides = layout.strides_bytes[..layout.rank as usize]
            .iter()
            .map(|&n| {
                i64::try_from(n / layout.element_bytes)
                    .map_err(|_| publication_input_error("DLPack stride exceeds signed extent"))
            })
            .collect::<Result<Vec<_>, _>>()?;
        let dtype = match layout.scalar_type {
            1 => (1, 8),
            2 => (1, 32),
            3 => (1, 64),
            4 => (2, 16),
            5 => (4, 16),
            6 => (2, 32),
            7 => (0, 64),
            8 => (6, 8),
            9 => (2, 64),
            _ => return Err(SemanticTransitionError::ObservationMismatch),
        };
        self.export_publication_tensor_view(
            lease,
            range.role,
            view,
            shape,
            strides,
            dtype,
            consumer_stream,
        )
    }

    #[expect(
        clippy::too_many_arguments,
        reason = "publication export keeps authenticated role and DLPack geometry explicit"
    )]
    fn export_publication_tensor_view(
        &mut self,
        lease: &SemanticPublishedLease,
        role: u64,
        view: DeviceMemoryView<u8>,
        shape: Vec<i64>,
        strides: Vec<i64>,
        dtype: (u8, u8),
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        if matches!(role, 3 | 6..=13 | 18..=25) {
            self.export_step_view(lease, view, shape, strides, dtype, consumer_stream)
        } else {
            self.export_reader_view(lease, view, shape, strides, dtype, consumer_stream)
        }
    }

    fn export_publication_bank_field(
        &mut self,
        lease: &SemanticPublishedLease,
        field: PublicationBankField,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        let inputs = self.ensure_step_inputs(lease)?;
        let (_, shape, strides) = field.layout();
        self.export_step_view(
            lease,
            inputs.field_view(field)?,
            shape,
            strides,
            (1, 64),
            consumer_stream,
        )
    }

    fn export_reader_view(
        &mut self,
        lease: &SemanticPublishedLease,
        view: DeviceMemoryView<u8>,
        shape: Vec<i64>,
        strides: Vec<i64>,
        dtype: (u8, u8),
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        let guard = Arc::clone(&self.checked_reader(lease)?.aliases);
        self.readers
            .get_mut(&lease.token)
            .expect("validated native reader")
            .consumer_streams
            .insert(consumer_stream);
        self.export_owned_view(view, shape, strides, dtype, guard, consumer_stream)
    }

    fn export_step_view(
        &mut self,
        lease: &SemanticPublishedLease,
        view: DeviceMemoryView<u8>,
        shape: Vec<i64>,
        strides: Vec<i64>,
        dtype: (u8, u8),
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        let guard = Arc::clone(&self.checked_step(lease)?.aliases);
        self.steps
            .get_mut(&lease.token)
            .expect("validated output step")
            .consumer_streams
            .insert(consumer_stream);
        self.export_owned_view(view, shape, strides, dtype, guard, consumer_stream)
    }

    fn export_owned_view(
        &mut self,
        view: DeviceMemoryView<u8>,
        shape: Vec<i64>,
        strides: Vec<i64>,
        dtype: (u8, u8),
        guard: Arc<()>,
        consumer_stream: u64,
    ) -> Result<DlpackManagedTensor, SemanticTransitionError> {
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("owned export stream admission", error))?;
        // The actual bank or step has retained this stream before enqueue.
        // Its final retirement joins use even if the capsule was deleted early.
        if let Err(error) = self.order_content_consumers(consumer_stream) {
            self.poisoned = true;
            return Err(error);
        }
        Ok(export_owned_allocation(
            view,
            shape,
            strides,
            dtype,
            self.provider.device().ordinal() as i32,
            guard,
            storage,
            None,
            None,
        ))
    }

    // Shared cold completion for export, final comparison and release. It joins
    // submitted work only, without dropping content, aliases or the native lease.
    fn complete_step_consumers(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        self.checked_step(lease)?;
        self.complete_step_consumers_by_token(lease.token, consumer_streams)
    }

    fn complete_step_consumers_by_token(
        &mut self,
        token: u64,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        let streams = self.step_consumer_streams(token, consumer_streams)?;
        let result = (|| {
            self.stream
                .context()
                .bind_to_thread()
                .map_err(|error| runtime_error("release context binding", error))?;
            for stream in streams {
                let event = self
                    .stream
                    .context()
                    .new_event(None)
                    .map_err(|error| runtime_error("consumer completion event", error))?;
                self.release_events.push(event);
                let event = self.release_events.last().expect("retained consumer event");
                // SAFETY: trusted consumer supplied its actual stream on this
                // device; the driver validates it. Record after the last use.
                unsafe {
                    cudarc::driver::result::event::record(
                        event.cu_event(),
                        dlpack_consumer_stream(stream)?,
                    )
                }
                .map_err(|error| runtime_error("consumer final event record", error))?;
                self.stream
                    .wait(event)
                    .map_err(|error| runtime_error("consumer final event join", error))?;
            }
            wait_on_stream(
                &self.stream,
                &mut self.poisoned,
                &mut self.stream_waits,
                "published reader consumer completion",
                CudaStream::synchronize,
            )?;
            Ok(())
        })();
        if result.is_err() {
            self.poisoned = true;
        } else {
            // Every retained event's recorded work and native-stream wait has
            // completed. Retire them here, even when export keeps readers live;
            // CudaEvent::drop binds its retained context before destruction.
            self.release_events.clear();
        }
        result
    }

    fn step_consumer_streams(
        &self,
        token: u64,
        consumer_streams: &[u64],
    ) -> Result<BTreeSet<u64>, SemanticTransitionError> {
        let step = self
            .steps
            .get(&token)
            .ok_or_else(|| publication_input_error("original step has been fully released"))?;
        let mut streams = consumer_streams.iter().copied().collect::<BTreeSet<_>>();
        if !step.consumer_streams.is_subset(&streams)
            || self
                .readers
                .get(&token)
                .is_some_and(|reader| !reader.consumer_streams.is_subset(&streams))
        {
            return Err(publication_input_error(
                "release omits a consumer stream that received a published alias",
            ));
        }
        for &stream in &streams {
            dlpack_consumer_stream(stream)?;
        }
        // Managed tensor producers negotiated readiness onto the legacy default
        // stream. Join it even when validation rejected a handoff before hashing.
        if !step.content.is_empty() {
            streams.insert(1);
        }
        Ok(streams)
    }

    /// Retire all aliases and their final consumer use while keeping the actual
    /// native reader acquired. This cold boundary performs the same completion
    /// checks as release, but no native decrement. It permits final guarded
    /// comparison after callbacks have relinquished their writable aliases.
    pub fn quiesce_published_reader(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("reader quiescence stream admission", error))?;
        self.checked_reader(lease)?;
        self.quiesce_step_content(lease, consumer_streams)
    }

    fn quiesce_step_content(
        &mut self,
        lease: &SemanticPublishedLease,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        let step = self.checked_step(lease)?;
        if Arc::strong_count(&step.content_witnesses) != 1 {
            return Err(publication_input_error(
                "content witnesses still retain this step",
            ));
        }
        if step.content.is_empty()
            && (Arc::strong_count(&step.aliases) != 1
                || self
                    .readers
                    .get(&lease.token)
                    .is_some_and(|reader| Arc::strong_count(&reader.aliases) != 1))
        {
            return Err(publication_input_error(
                "published tensor aliases still retain this reader",
            ));
        }
        self.complete_step_consumers(lease, consumer_streams)?;
        // Captured producers may themselves be exports of this same parent.
        // Retire those internal aliases only after their final device use and
        // after all witnesses are gone; then distinguish real external aliases.
        let step = self
            .steps
            .get_mut(&lease.token)
            .expect("completed content step");
        step.content.clear();
        if Arc::strong_count(&step.aliases) != 1 {
            return Err(publication_input_error(
                "output aliases still retain this step",
            ));
        }
        if self
            .readers
            .get(&lease.token)
            .is_some_and(|reader| Arc::strong_count(&reader.aliases) != 1)
        {
            return Err(publication_input_error(
                "published tensor aliases still retain this reader",
            ));
        }
        Ok(())
    }

    /// Retire only the actual publication reader after final bank use. Original
    /// numerical content, producer seals and policy outputs retain this step.
    /// A live bank alias still prevents reuse; no retained content is discarded.
    pub fn release_published_reader(
        &mut self,
        lease: &mut SemanticPublishedLease,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        #[cfg(feature = "semantic-policy")]
        self.require_closed_evaluations()?;
        // This public cold boundary waits and reads completion metadata. Keep
        // the entire call outside capture, including the final bank decrement.
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("reader retirement stream admission", error))?;
        self.checked_step(lease)?;
        let reader = self.checked_reader(lease)?;
        if Arc::strong_count(&reader.aliases) != 1
            || self
                .admitted_transition
                .is_some_and(|(token, _, _)| token == lease.token)
        {
            return Err(publication_input_error(
                "publication reader still owns aliases or an admitted transition",
            ));
        }
        self.complete_step_consumers(lease, consumer_streams)?;
        self.retire_published_reader(lease)
    }

    fn retire_published_reader(
        &mut self,
        lease: &mut SemanticPublishedLease,
    ) -> Result<(), SemanticTransitionError> {
        let reader = self.checked_reader(lease)?;
        if Arc::strong_count(&reader.aliases) != 1
            || (self
                .admitted_transition
                .is_some_and(|(token, _, _)| token == lease.token)
                && (self.continuation_base.is_some() || self.text_binding.is_some()))
        {
            return Err(publication_input_error(
                "publication reader still owns aliases or an unfinished transition",
            ));
        }
        let result = (|| {
            self.publication_command(3, Some(lease.token))?;
            let result = self.publication_read(self.readers[&lease.token].device.view())?[0];
            if result.status != 0
                || result.active != 0
                || result.instance != lease.identity.instance
                || result.word != lease.identity.word
            {
                return Err(SemanticTransitionError::PublicationRefused {
                    status: result.status,
                });
            }
            Ok(())
        })();
        if result.is_err() {
            self.poisoned = true;
            return result;
        }
        lease.active = false;
        self.readers.remove(&lease.token);
        if self
            .admitted_transition
            .is_some_and(|(token, _, _)| token == lease.token)
        {
            self.admitted_transition = None;
        }
        Ok(())
    }

    /// All aliases must have returned their managed owners. Completion events
    /// are recorded after final consumer use, joined, and completed before the
    /// sole native reader decrement, unless that reader has already retired.
    /// Failure retains the original step and every unfinished owner.
    pub fn release(
        &mut self,
        lease: &mut SemanticPublishedLease,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        #[cfg(feature = "semantic-policy")]
        self.require_closed_evaluations()?;
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("step retirement stream admission", error))?;
        self.quiesce_step_content(lease, consumer_streams)?;
        if lease.active {
            self.retire_published_reader(lease)?;
        }
        self.steps.remove(&lease.token);
        self.release_events.clear();
        Ok(())
    }

    /// Join final consumers and retire one actually completed prepared owner.
    /// The device reader was released by its recorded body; this cold operation
    /// never issues a second decrement or replaces its original private seals.
    pub fn release_prepared_step(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("prepared step retirement stream admission", error))?;
        self.quiesce_prepared_step(step, consumer_streams)?;
        let owner = self
            .steps
            .get_mut(&step.token)
            .expect("completed prepared step");
        let prepared = owner.prepared.as_mut().expect("prepared owner");
        // These are internal handles, not outstanding consumer witnesses.
        // Actual tensor owners remain in content until the final checks below.
        for branch in &mut prepared.branches {
            branch.continuation = None;
            #[cfg(feature = "semantic-policy")]
            {
                branch.policy_witness = None;
                branch.policy = None;
                branch.policy_sources.clear();
            }
        }
        if Arc::strong_count(&owner.content_witnesses) != 1 {
            return Err(publication_input_error(
                "content witnesses still retain this prepared step",
            ));
        }
        owner.content.clear();
        if Arc::strong_count(&owner.aliases) != 1 {
            return Err(publication_input_error(
                "output aliases still retain this prepared step",
            ));
        }
        self.steps.remove(&step.token);
        Ok(())
    }

    /// Establish final device use without discarding the producer owners. This
    /// permits the caller to retire callback-owned aliases outside its mutex.
    pub fn quiesce_prepared_step(
        &mut self,
        step: &SemanticPreparedStep,
        consumer_streams: &[u64],
    ) -> Result<(), SemanticTransitionError> {
        self.checked_prepared_step(step, false)?;
        if !self
            .prepared_segment
            .as_ref()
            .expect("checked prepared scope")
            .completed
        {
            return Err(publication_input_error(
                "prepared step cannot retire before actual segment completion",
            ));
        }
        #[cfg(feature = "semantic-policy")]
        if self
            .policy_tapes
            .iter()
            .any(|tape| tape.policy.text_binding._witness.reader_token == step.token)
        {
            return Err(SemanticTransitionError::UnconsumedPolicyTape);
        }
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("prepared step quiescence stream admission", error))?;
        self.complete_step_consumers_by_token(step.token, consumer_streams)
    }

    pub fn admit_transition(
        &mut self,
        lease: &SemanticPublishedLease,
        kind: SemanticTransitionKind,
    ) -> Result<(), SemanticTransitionError> {
        #[cfg(feature = "semantic-policy")]
        self.require_closed_evaluations()?;
        self.checked_reader(lease)?;
        if kind == SemanticTransitionKind::Update {
            return Err(publication_input_error(
                "updates require a prepared step with native training and pending-output owners",
            ));
        }
        if self.admitted_transition.is_some() || self.continuation_base.is_some() {
            return Err(publication_input_error(
                "an admitted transition already owns the pending invocation",
            ));
        }
        let control = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let current = self.publication_read(control.control.view())?[0];
        if current.instance != lease.identity.instance || current.word != lease.identity.word {
            return Err(publication_input_error(
                "transition requires the current acquired parent, not an older retained reader",
            ));
        }
        if lease.header.terminal == 2 {
            return Err(publication_input_error(
                "final publication admits reads, not another transition",
            ));
        }
        let reserve = if matches!(
            kind,
            SemanticTransitionKind::Proposal | SemanticTransitionKind::Drain
        ) {
            2
        } else {
            1
        };
        if lease.header.fuel < reserve {
            return Err(publication_input_error(
                "acquired publication has insufficient transition fuel",
            ));
        }
        if (lease.header.terminal == 1) != (kind == SemanticTransitionKind::Drain) {
            return Err(SemanticTransitionError::PublicationRefused { status: 4 });
        }
        self.admitted_transition = Some((lease.token, lease.identity.word, kind));
        Ok(())
    }

    /// Snapshot original forward outputs against this exact admitted reader.
    /// Completion records and outputs must come from the forward that consumed
    /// the acquired parent; metadata alone never grants use authority.
    pub fn bind_continuation(
        &mut self,
        lease: &SemanticPublishedLease,
        continuation: SemanticContinuationInput,
        witness: &SemanticTensorContentWitness,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let mut handoff = RetainedTensorAdmission {
            inputs: Some(vec![continuation]),
            stream: Arc::clone(self.provider.device().inner().stream()),
            ready: false,
        };
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("continuation stream admission", error))?;
        self.checked_reader(lease)?;
        self.ensure_rebindable()?;
        self.checked_content_witness(lease, witness)?;
        dlpack_consumer_stream(consumer_stream)?;
        let (_, base_word, kind) = self
            .admitted_transition
            .filter(|(token, word, _)| *token == lease.token && *word == lease.identity.word)
            .ok_or_else(|| {
                publication_input_error(
                    "continuation has no admitted invocation for this exact acquired reader",
                )
            })?;
        if self.continuation_base.is_some() {
            return Err(publication_input_error(
                "an unconsumed continuation already owns the pending bank",
            ));
        }
        if !matches!(
            self.steps[&lease.token].content[witness.index].seals,
            TensorContentSeals::Captured(_)
        ) {
            return Err(publication_input_error(
                "continuation requires its original transient producer witness",
            ));
        }
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let continuation = handoff
            .inputs
            .as_ref()
            .expect("retained continuation")
            .first()
            .expect("one continuation");
        let tensor_count = continuation.tensors.len();
        let active_capacity = storage
            .contract_value
            .feedback_capacity
            .checked_add(32)
            .ok_or_else(|| publication_input_error("continuation active capacity overflow"))?;
        let (physical_blocks, model_schema_digest, model_identity) =
            storage.continuation_block_contract(kind, continuation, false)?;
        let service_layouts =
            continuation_service_layouts(tensor_count, active_capacity, physical_blocks)?;
        if continuation.authority_decisions.is_empty() {
            return Err(publication_input_error(
                "continuation lacks its actual fresh authority decision snapshot",
            ));
        }
        let continuation = handoff
            .inputs
            .take()
            .expect("retained continuation")
            .pop()
            .expect("one continuation");
        let SemanticContinuationInput {
            mut tensors,
            authority_decisions,
            text_rows,
            text_row_count,
            selected_text,
            active_rows,
            active_row_count,
            numerical_admissibility,
            numerical_blocks,
            model_schema_digest: _,
            model_identity: _,
        } = continuation;
        let mut services = vec![
            text_rows,
            text_row_count,
            selected_text,
            active_rows,
            active_row_count,
            numerical_admissibility,
        ];
        services.extend(numerical_blocks);
        tensors.extend(
            services
                .into_iter()
                .zip(service_layouts)
                .map(|(tensor, layout)| SemanticTensorInput {
                    layout,
                    logical_begin: 0,
                    logical_end: 0,
                    tensor,
                    native_allocation: None,
                }),
        );
        // Verify the same roster against its original private digest. This is
        // an event-ordered device guard, not a new capture or a host value read.
        self.verify_tensor_content(lease, witness, tensors, consumer_stream)?;
        let numerical_block_snapshot = if let Some(blocks) = physical_blocks {
            let original =
                self.steps[&lease.token].content[witness.index].tensors[tensor_count + 6].clone();
            let cells = blocks
                .checked_mul(6)
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            let snapshot = Arc::new(allocate_publication::<f64>(&self.provider, cells)?);
            enqueue_numerical_block_snapshot(
                &self.domain,
                &mut self.poisoned,
                &original,
                &snapshot,
            )?;
            Some(snapshot)
        } else {
            None
        };
        let original = &self.steps[&lease.token].content[witness.index].tensors;
        let services = original[tensor_count..].to_vec();
        if services.len() != 6 + usize::from(physical_blocks.is_some()) {
            return Err(publication_input_error(
                "continuation witness has the wrong original service roster",
            ));
        }
        let text_binding = Arc::new(TextBindingStorage {
            inputs: services,
            numerical_block_snapshot,
            model_contract: None,
            physical_blocks: physical_blocks.unwrap_or(0) as u64,
            model_schema_digest,
            model_identity,
            _witness: witness.clone(),
            _model_content_witness: None,
            consumer_stream,
            parent: TextBindingParent::Published {
                bank: (lease.identity.word & 1) as usize,
                header: lease.header,
            },
        });
        let authority_bytes = authority_decisions.len() as u64;
        let (uploads, pending_layouts) = prepare_continuation_payloads(
            &storage,
            &original[..tensor_count],
            &authority_decisions,
            kind,
        )?;
        let prepared = PreparedContinuation::prepare(
            &self.provider,
            Arc::clone(&storage),
            self.checked_reader(lease)?.device.view(),
            Arc::clone(&text_binding),
            text_binding.continuation_inputs(
                kind,
                authority_bytes,
                0,
                ModelUpdateContinuationInputs::default(),
            ),
            None,
            &uploads,
            &pending_layouts,
        )?;
        // Install the same concrete owners before any upload/copy can enqueue.
        // On error or unwind, step retirement and Session quarantine retain
        // sources, original witness/services, destination storage and the lease.
        self.publication_uploads = uploads;
        self.text_binding = Some(Arc::clone(&text_binding));
        let result = (|| {
            for (slot, payload) in &self.publication_uploads {
                if let PublicationPayload::Metadata(bytes) = payload {
                    if !bytes.is_empty() {
                        let mut destination =
                            storage.allocations[*slot].view().slice(..bytes.len());
                        self.provider
                            .htod_launch_metadata_sync_copy_into(bytes, &mut destination)
                            .map_err(|error| {
                                runtime_error("continuation fresh authority upload", error)
                            })?;
                    }
                }
            }
            prepared.enqueue(&self.domain, &mut self.poisoned)
        })();
        if let Err(error) = result {
            self.poisoned = true;
            return Err(error);
        }
        if let Err(error) = self.order_content_consumers(consumer_stream) {
            self.poisoned = true;
            return Err(error);
        }
        self.publication_uploads.clear();
        self.continuation_base = Some(base_word);
        #[cfg(feature = "semantic-policy")]
        if kind == SemanticTransitionKind::Proposal {
            self.attach_policy_continuation()?;
        }
        if kind != SemanticTransitionKind::Proposal {
            let rng = self.continuation_rng(lease)?;
            self.captured = None;
            self.rng = Some(rng);
            self.next_proposal = u64::from(rng.proposal);
        }
        Ok(())
    }

    pub fn policy_layout(&self) -> Result<SemanticPolicyLayout, SemanticTransitionError> {
        self.ensure_quiescent()?;
        SemanticPolicyLayout::from_components(&self.codebooks.components)
    }

    /// All original category spans in native catalogue order. Inactive TEXT
    /// retains its reserved span, but the device emits singleton NULL without
    /// reading that span. Selection never changes subsequent category offsets.
    pub fn policy_support_layout(
        &self,
    ) -> Result<(Vec<std::ops::Range<usize>>, usize), SemanticTransitionError> {
        self.ensure_quiescent()?;
        Ok(self.codebooks.support_layout())
    }

    pub fn new(
        provider: &Arc<CudaKernelProvider>,
        domain: &ResidentExecutionDomain,
    ) -> Result<Self, SemanticTransitionError> {
        let mut graph = provider
            .allocate_semantic_hypergraph(
                domain,
                SemanticHypergraphCapacities::try_new(3, 4, 4, 4)
                    .map_err(SemanticTransitionError::Semantic)?,
            )
            .map_err(SemanticTransitionError::Semantic)?;
        let base = graph.empty_root();
        graph
            .admit_records(
                base,
                SemanticAdmissionRecords {
                    predicates: vec![],
                    records: vec![],
                    supports: vec![],
                },
                SemanticAdmissionLimits {
                    max_records: 0,
                    max_terms: 0,
                    max_references: 0,
                    max_utf8_bytes: 0,
                },
            )
            .map_err(SemanticTransitionError::Semantic)?;
        Self::from_hypergraph(graph)
    }

    /// Consumes the sole admitted semantic owner. The acquired base, accepted
    /// symbol bytes, descriptors and arena remain inseparable for capture/replay.
    pub fn from_hypergraph(graph: SemanticHypergraph) -> Result<Self, SemanticTransitionError> {
        Self::from_hypergraph_with_program(graph, None)
    }

    /// Bind the source-derived edit grammar before allocating the resident
    /// codebooks and policy buffers. The task observer is bound separately.
    pub fn from_hypergraph_with_program(
        graph: SemanticHypergraph,
        program: Option<&crate::SemanticProgramAdmission>,
    ) -> Result<Self, SemanticTransitionError> {
        let (provider, domain) = graph
            .transition_owner()
            .map_err(SemanticTransitionError::Semantic)?;
        validate_execution_domain(&provider, &domain)
            .map_err(|e| runtime_error("domain validation", e))?;
        let execute = provider
            .device()
            .inner()
            .get_func("xlog_semantic_transition", "semantic_transition_execute")
            .ok_or_else(|| {
                runtime_error("kernel lookup", "semantic transition kernel unavailable")
            })?;
        let admission = graph
            .admission()
            .expect("transition owner validated admission");
        let root = admission.base();
        let base_snapshot = *admission.base_snapshot();
        let codebooks = ActionCodebooks::derive(admission, graph.transition_arena()[1], program)?;
        let bytes = codebooks.input_cells * (size_of::<f32>() + size_of::<u8>())
            + SCRATCH_BYTES
            + OBSERVATION_BYTES
            + codebooks.words.len() * 8
            + COMPONENT_COUNT * size_of::<SemanticComponent>();
        let mut reservation = provider
            .memory()
            .reserve_bytes(bytes as u64)
            .map_err(|e| runtime_error("reservation", e))?;
        let logits = reservation
            .alloc::<f32>(codebooks.input_cells)
            .map_err(|e| runtime_error("logits allocation", e))?;
        let support = reservation
            .alloc::<u8>(codebooks.input_cells)
            .map_err(|e| runtime_error("support allocation", e))?;
        let scratch = reservation
            .alloc::<u64>(SCRATCH_BYTES / 8)
            .map_err(|e| runtime_error("scratch allocation", e))?;
        let receipts = reservation
            .alloc::<SemanticTransitionReceipt>(COMPONENT_COUNT)
            .map_err(|e| runtime_error("receipt allocation", e))?;
        let state = reservation
            .alloc::<DeviceState>(1)
            .map_err(|e| runtime_error("state allocation", e))?;
        let device_codebooks = reservation
            .alloc::<u64>(codebooks.words.len())
            .map_err(|e| runtime_error("codebook allocation", e))?;
        let device_components = reservation
            .alloc::<SemanticComponent>(COMPONENT_COUNT)
            .map_err(|e| runtime_error("component allocation", e))?;
        debug_assert_eq!(reservation.remaining_bytes(), 0);
        let stream = provider
            .memory()
            .runtime()
            .and_then(|r| r.stream_pool().resolve(domain.stream_id()))
            .ok_or_else(|| runtime_error("stream resolution", "owned stream is unavailable"))?;
        let mut session = Self {
            captured: None,
            provider,
            domain: domain.clone(),
            stream: stream.clone(),
            graph: std::mem::ManuallyDrop::new(graph),
            root,
            base_snapshot,
            codebooks,
            device_codebooks,
            device_components,
            task: None,
            cold_content: None,
            initial_prefill: None,
            retained_initial_prefill: None,
            checkpoint_initial_prefill: None,
            training_views: None,
            training_origins: None,
            task_epoch: 0,
            task_observed: false,
            publication: None,
            learning_phases: Vec::new(),
            publication_uploads: Vec::new(),
            publication_issuer: Arc::new(()),
            readers: BTreeMap::new(),
            steps: BTreeMap::new(),
            next_reader: 0,
            prepared_segment: None,
            prepared_resources: Vec::new(),
            continuation_base: None,
            text_binding: None,
            admitted_transition: None,
            release_events: Vec::new(),
            logits,
            support,
            scratch,
            receipts,
            state,
            pinned: PinnedObservation::new(stream.clone())?,
            execute,
            #[cfg(feature = "semantic-policy")]
            policy: None,
            #[cfg(feature = "semantic-policy")]
            pending_policy: None,
            #[cfg(feature = "semantic-policy")]
            policy_tapes: Vec::new(),
            rng: None,
            next_proposal: 0,
            pending: false,
            poisoned: false,
            stream_waits: 0,
        };
        session.validate_ranges()?;
        session.upload_cold_codebooks()?;
        Ok(session)
    }

    pub fn is_poisoned(&self) -> bool {
        self.poisoned || self.graph.ensure_not_poisoned().is_err()
    }

    /// Irreversibly close this owner after trusted application validation fails,
    /// including a failure discovered after cold parent binding has completed.
    /// All existing readers/controllers consult this same poison state before
    /// further execution. Repeated aborts are harmless; no resource is freed,
    /// no device work is enqueued, and no poisoned CUDA context is reset.
    /// Existing recorded retirement/quarantine retains outstanding owners.
    /// A fatal CUDA error still requires termination of the isolated process.
    pub fn abort(&mut self) {
        self.poisoned = true;
    }

    /// Join the actual cold observer before its fresh, unpublished Session is
    /// removed from the Python owner. A failed wait keeps every allocation in
    /// that owner and prohibits a restored Session from overlapping it.
    pub fn join_observed_cold_release(&mut self) -> Result<(), SemanticTransitionError> {
        if self.is_poisoned()
            || self.cold_content.is_none()
            || self.task.is_some()
            || self.task_epoch != 0
            || self.task_observed
            || self.publication.is_some()
            || self.captured.is_some()
            || !self.readers.is_empty()
            || !self.steps.is_empty()
            || self.prepared_segment.is_some()
            || self.initial_prefill.is_some()
            || self.retained_initial_prefill.is_some()
            || self.checkpoint_initial_prefill.is_some()
        {
            return Err(publication_input_error(
                "cold release requires the observed, unpublished fresh task",
            ));
        }
        let result = self
            .stream
            .context()
            .bind_to_thread()
            .and_then(|_| self.stream.context().synchronize());
        if let Err(error) = result {
            self.poisoned = true;
            return Err(runtime_error("fresh cold observer completion", error));
        }
        Ok(())
    }

    /// Destroy the joined cold owner outside the Python Session mutex, then
    /// complete the allocator's real pending deallocations before returning.
    pub fn finish_observed_cold_release(self) -> Result<(), SemanticTransitionError> {
        let memory = Arc::clone(self.provider.memory());
        drop(self);
        memory
            .reap_pending_deallocations()
            .map_err(|error| runtime_error("fresh cold allocation retirement", error))?;
        if memory.allocated_bytes() != 0
            || memory
                .runtime()
                .is_some_and(|runtime| runtime.bytes_outstanding() != 0)
        {
            return Err(publication_input_error(
                "fresh cold allocation owners remain after retirement",
            ));
        }
        Ok(())
    }

    /// Inspect the actual cold root, or a decoded replay predecessor, through
    /// the retained native admission before importing its task authority.
    /// The selected replay is not restored here, and these records establish
    /// neither historical execution nor any current use permission.
    pub fn task_observation_roots(
        &mut self,
        spec: &SemanticTaskEvaluationSpec,
        replay: Option<&SemanticReplayMaterial>,
    ) -> Result<SemanticTaskObservationRoots, SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some() || self.captured.is_some() {
            return Err(publication_input_error(
                "task observation roots require a cold unpublished Session",
            ));
        }
        let admission = self
            .graph
            .admission()
            .ok_or(SemanticTransitionError::NotBound)?;
        spec.validate_records(admission.records())?;
        if let Some(replay) = replay {
            return replay
                .predecessor
                .graph
                .task_observation_roots(admission, spec.statement_records)
                .map_err(SemanticTransitionError::Semantic);
        }
        let material = self
            .graph
            .export_transition_root(self.root)
            .map_err(SemanticTransitionError::Semantic)?;
        let admission = self
            .graph
            .admission()
            .ok_or(SemanticTransitionError::NotBound)?;
        material
            .task_observation_roots(admission, spec.statement_records)
            .map_err(SemanticTransitionError::Semantic)
    }

    /// Execute the supplied native observer and bind its outputs to this admission.
    /// This data binding does not issue publication, inference, or training rights.
    /// The trusted controller must independently import those rights before use.
    pub fn bind_task_evaluation(
        &mut self,
        spec: SemanticTaskEvaluationSpec,
    ) -> Result<Identity256, SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some() {
            return Err(publication_input_error(
                "task data is immutable after its canonical parent is initialized",
            ));
        }
        let admission = self
            .graph
            .admission()
            .ok_or(SemanticTransitionError::NotBound)?;
        let next_epoch = self
            .task_epoch
            .checked_add(1)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        spec.validate_records(admission.records())?;
        if spec
            .program
            .editable_program()
            .map(ActionCodebooks::program_binding)
            != self.codebooks.program_binding
        {
            return Err(publication_input_error(
                "task editable program differs from the cold action grammar",
            ));
        }
        let observation = spec
            .program
            .observe(Arc::clone(&self.provider))
            .inspect_err(|_error| {
                self.poisoned = true;
            })?;
        let binding = TaskEvaluationBinding::bind(admission, spec, observation)?;
        if self
            .cold_content
            .is_some_and(|expected| binding.content() != expected)
        {
            self.poisoned = true;
            return Err(publication_input_error(
                "final task content differs from the executed cold admission",
            ));
        }
        #[cfg(feature = "semantic-policy")]
        {
            let material = self
                .graph
                .export_transition_root(self.root)
                .map_err(SemanticTransitionError::Semantic)?;
            if material.digest != *self.base_snapshot.digest().as_bytes() {
                self.poisoned = true;
                return Err(SemanticTransitionError::ObservationMismatch);
            }
        }
        let words = binding.words(self.graph.transition_arena()[1]);
        let mut reservation = self
            .provider
            .memory()
            .reserve_bytes((words.len() * size_of::<u64>()) as u64)
            .map_err(|error| runtime_error("private task reservation", error))?;
        let device = reservation
            .alloc::<u64>(words.len())
            .map_err(|error| runtime_error("private task allocation", error))?;
        // Retain the new owner before the first may-enqueue boundary. A failed
        // upload/adoption poisons reuse and keeps its storage until Session drop.
        self.captured = None;
        let identity = binding.identity();
        self.task = Some((binding, device));
        let (_, device) = self.task.as_mut().expect("private task installed above");
        self.provider
            .htod_sync_copy_into_tracked(&words, device)
            .map_err(|error| {
                self.poisoned = true;
                runtime_error("private task upload", error)
            })?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read_write(device);
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |_| {
            Ok::<(), XlogError>(())
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "private task adoption wait",
            CudaStream::synchronize,
        )?;
        self.validate_ranges()?;
        self.task_epoch = next_epoch;
        Ok(identity)
    }

    /// Execute the same native observer before the final task import so a
    /// context admission can bind its original task content. This read grants
    /// no use authority; final import must reproduce the same content exactly.
    pub fn observe_cold_task_content(
        &mut self,
        statement_records: [u32; 3],
        allowed_support_records: &[u32],
        program: &dyn SemanticTaskProgram,
    ) -> Result<(SemanticTaskContentIdentity, [crate::SemanticTruth; 3]), SemanticTransitionError>
    {
        self.ensure_rebindable()?;
        if self.publication.is_some() || self.task.is_some() || self.cold_content.is_some() {
            return Err(publication_input_error(
                "cold task content can be observed only once before final import",
            ));
        }
        let admission = self
            .graph
            .admission()
            .ok_or(SemanticTransitionError::NotBound)?;
        if program
            .editable_program()
            .map(ActionCodebooks::program_binding)
            != self.codebooks.program_binding
        {
            return Err(publication_input_error(
                "cold task observer differs from the admitted edit grammar",
            ));
        }
        let observation = program
            .observe(Arc::clone(&self.provider))
            .inspect_err(|_| self.poisoned = true)?;
        let content = TaskEvaluationBinding::cold_content(
            admission,
            statement_records,
            allowed_support_records,
            program.editable_program(),
            observation,
        )
        .inspect_err(|_| self.poisoned = true)?;
        self.cold_content = Some(content);
        Ok(content)
    }

    /// Bind the controller's independently validated goal closure to the native
    /// task bank before any publication, capture, or model work may begin.
    pub fn bind_task_goal_witness(
        &mut self,
        witness: SemanticTaskGoalWitness,
    ) -> Result<Identity256, SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some() || self.captured.is_some() {
            return Err(publication_input_error(
                "goal authority is immutable after publication or capture",
            ));
        }
        if witness.mandatory_link_count == 0
            || witness.constraint_count == 0
            || witness
                .semantic_root
                .as_bytes()
                .iter()
                .all(|byte| *byte == 0)
            || witness
                .authority_root
                .as_bytes()
                .iter()
                .all(|byte| *byte == 0)
            || witness
                .mandatory_links_root
                .as_bytes()
                .iter()
                .all(|byte| *byte == 0)
            || witness
                .constraints_root
                .as_bytes()
                .iter()
                .all(|byte| *byte == 0)
        {
            return Err(publication_input_error(
                "goal authority requires nonempty independently validated roots and closures",
            ));
        }
        let next_epoch = self
            .task_epoch
            .checked_add(1)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let (binding, device) = self.task.as_mut().ok_or_else(|| {
            publication_input_error("goal authority requires a bound native task evaluation")
        })?;
        if binding.goal_witness.is_some() {
            return Err(publication_input_error(
                "goal authority can be bound only once",
            ));
        }
        binding.goal_witness = Some(witness);
        let identity = binding.identity();
        let words = binding.words(self.graph.transition_arena()[1]);
        self.provider
            .htod_sync_copy_into_tracked(&words, device)
            .map_err(|error| {
                self.poisoned = true;
                runtime_error("private goal-authority upload", error)
            })?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read_write(device);
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |_| {
            Ok::<(), XlogError>(())
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "private goal-authority adoption wait",
            CudaStream::synchronize,
        )?;
        self.validate_ranges()?;
        self.task_epoch = next_epoch;
        Ok(identity)
    }

    /// Identity of the immutable task data bank, not a use-authority token.
    pub fn task_evaluation_identity(&self) -> Option<Identity256> {
        self.task.as_ref().map(|(binding, _)| binding.identity())
    }

    /// Exact content identities and observed truths of the currently bound
    /// task, excluding its controller authority and scoring policy.
    pub fn task_content(&self) -> Option<(SemanticTaskContentIdentity, [crate::SemanticTruth; 3])> {
        self.task.as_ref().map(|(binding, _)| binding.content())
    }

    /// Identity of the exact scoring law bound to the current native task.
    pub fn task_scoring_law_identity(
        &self,
    ) -> Result<Option<Identity256>, SemanticTransitionError> {
        Ok(self.task.as_ref().map(|(binding, _)| {
            checkpoint_scoring_law_identity(
                binding.spec.scoring,
                binding.content_identity(),
                binding.objective_law,
                binding.spec.training_domain.as_ref(),
            )
        }))
    }

    /// The same cold law used by arena admission and checkpoint identity, with
    /// no selected denominators or actor-eligibility grant. No device read occurs.
    pub fn task_objective_law(&self) -> Option<SemanticTaskObjectiveLaw> {
        self.task.as_ref().map(|(binding, _)| binding.objective_law)
    }

    /// Immutable pre-action input domain. No device read or use grant occurs.
    pub fn task_training_domain(&self) -> Option<&SemanticTrainingDomain> {
        self.task
            .as_ref()
            .and_then(|(binding, _)| binding.spec.training_domain.as_ref())
    }

    /// Original pre-draw actor/full domains. Reading them grants no execution
    /// or training use. The consumer retains all capsules through final use;
    /// aliases must not be written while any original consumer remains live.
    #[cfg(feature = "semantic-policy")]
    pub fn policy_numerical_domains(
        &mut self,
        parent: &SemanticPublishedLease,
        consumer_stream: u64,
    ) -> Result<[DlpackManagedTensor; 3], SemanticTransitionError> {
        self.checked_reader(parent)?;
        dlpack_consumer_stream(consumer_stream)?;
        if self.captured.is_some() {
            return Err(publication_input_error(
                "uniform domains must precede policy capture",
            ));
        }
        let pending = self.pending_policy.as_ref().ok_or_else(|| {
            publication_input_error("uniform domains require the nine original policy snapshots")
        })?;
        if pending
            .witness
            .as_ref()
            .is_none_or(|(witness, _)| witness.reader_token != parent.token)
        {
            return Err(publication_input_error(
                "uniform domains belong to another acquired parent",
            ));
        }
        let publication = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let tensors = export_policy_uniform_domains(
            &pending.buffers,
            self.codebooks.input_cells,
            self.provider.device().ordinal() as i32,
            Arc::clone(&self.steps[&parent.token].aliases),
            publication,
        )?;
        self.steps
            .get_mut(&parent.token)
            .expect("checked original parent")
            .consumer_streams
            .insert(consumer_stream);
        self.order_content_consumers(consumer_stream)?;
        Ok(tensors)
    }

    /// Same producer and formats on a genuine cold-prepared Proposal bank,
    /// before its model work is frozen and its continuation is submitted.
    #[cfg(feature = "semantic-policy")]
    pub fn prepared_policy_numerical_domains(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        consumer_stream: u64,
    ) -> Result<[DlpackManagedTensor; 3], SemanticTransitionError> {
        self.check_prepared_content_stream(step, consumer_stream)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared policy bank must be zero or one",
            ));
        }
        let original = &self.steps[&step.token];
        let prepared = original.prepared.as_ref().expect("checked prepared owner");
        if prepared.transition_recorded & (1 << bank) != 0 {
            return Err(publication_input_error(
                "uniform domains must precede policy submission",
            ));
        }
        let branch = &prepared.branches[bank];
        if branch.policy_sources.len() != 9 {
            return Err(publication_input_error(
                "uniform domains require the nine original policy snapshots",
            ));
        }
        let buffers = branch
            .policy_buffers
            .as_ref()
            .or_else(|| branch.policy.as_ref().map(|policy| &policy.buffers))
            .ok_or_else(|| publication_input_error("original uniform policy bank is absent"))?;
        let tensors = export_policy_uniform_domains(
            buffers,
            self.codebooks.input_cells,
            self.provider.device().ordinal() as i32,
            Arc::clone(&original.aliases),
            Arc::clone(
                self.publication
                    .as_ref()
                    .ok_or(SemanticTransitionError::NotBound)?,
            ),
        )?;
        self.steps
            .get_mut(&step.token)
            .expect("checked original step")
            .consumer_streams
            .insert(consumer_stream);
        self.order_content_consumers(consumer_stream)?;
        Ok(tensors)
    }

    /// Semantic root of the validated goal witness bound to the current task.
    /// This is the same root retained in its completed task ground.
    pub fn task_semantic_goal_root(&self) -> Option<Identity256> {
        self.task
            .as_ref()
            .and_then(|(binding, _)| binding.goal_witness.map(|goal| goal.semantic_root))
    }

    /// Ordered priority levels from the same immutable native task binding
    /// consumed by the device selector and later completed task ground.
    pub fn task_priority_levels(&self) -> Option<&[SemanticTaskPriorityLevel]> {
        self.task
            .as_ref()
            .map(|(binding, _)| binding.priority_levels())
    }

    /// Bind every admitted training view once while the task is still cold.
    /// No row is selected here and the arena cannot be replaced after binding.
    pub fn bind_training_view_arena(
        &mut self,
        rows: Vec<SemanticTrainingViewRow>,
        objective: SemanticTrainingObjective,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some() || self.training_views.is_some() || self.task.is_none() {
            return Err(publication_input_error(
                "training-view arena requires one cold task binding and cannot be replaced",
            ));
        }
        self.task_objective_law()
            .expect("checked cold task binding")
            .require_objective(&objective)?;
        let task_identity = self
            .task
            .as_ref()
            .expect("checked cold task binding")
            .0
            .identity();
        let (task_content, expected_truth) = self
            .task
            .as_ref()
            .expect("checked cold task binding")
            .0
            .content();
        self.training_views = Some(SemanticTrainingViewArena::allocate(
            &self.provider,
            &self.domain,
            rows,
            objective,
            self.task_training_domain().ok_or_else(|| {
                publication_input_error(
                    "training arena requires its original pre-action input domain",
                )
            })?,
            task_identity,
            task_content,
            expected_truth,
        )?);
        Ok(())
    }

    /// Exact original admission selections in task query order, not inferred
    /// from canonical statement values. Support order and duplicates are kept
    /// as supplied to the validated binding. These indices grant no use rights.
    pub fn task_evaluation_spec(
        &self,
    ) -> Result<&SemanticTaskEvaluationSpec, SemanticTransitionError> {
        self.ensure_quiescent()?;
        let (task, _) = self
            .task
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        Ok(task.spec())
    }

    /// Native learned-value projection for the three fixed queries, in query order.
    /// Each payload is a length-delimited canonical predicate/arity/argument
    /// byte sequence followed by the ordered, length-delimited qualifier values.
    /// Encoding-domain and schema-digest service headers are excluded. The
    /// original qualified key identity remains separately bound to the task.
    /// These schema bytes contain no observer answers or use authority.
    pub fn feedback_statement_bytes(&self) -> Result<[&[u8]; 3], SemanticTransitionError> {
        let selected = self.task_evaluation_spec()?.statement_records;
        let (task, _) = self
            .task
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        Ok(selected.map(|record| task.statement_bytes[&record].as_slice()))
    }

    /// Identity of this build's actual native feedback projection source, not
    /// any statement value, task identity, observer answer or authority decision.
    pub fn feedback_adapter_identity() -> Identity256 {
        let mut hash = Sha256::new();
        hash.update(b"xlog.native.flat-feedback-adapter.v1\0");
        hash.update(include_bytes!("semantic_transition.rs"));
        hash.update(include_bytes!("../kernels/semantic_transition.cu"));
        hash.update(include_bytes!("../kernels/semantic_feedback_encoding.cuh"));
        Identity256::from_bytes(hash.finalize().into())
    }

    /// Changes on every successful task import, even when data bytes are identical.
    pub fn task_evaluation_epoch(&self) -> u64 {
        self.task_epoch
    }

    pub fn binding(&self) -> SemanticCatalogueBinding {
        self.codebooks.binding
    }
    pub fn components(&self) -> &[SemanticComponent] {
        &self.codebooks.components
    }
    pub fn descriptor_meaning(
        &self,
        field: u32,
        category: u32,
    ) -> Option<&SemanticActionDescriptor> {
        let entries = match field {
            2 => &self.codebooks.targets,
            3..=10 => &self.codebooks.operands,
            11 => &self.codebooks.qualifiers,
            17 => &self.codebooks.leaves,
            _ => return None,
        };
        entries.get(category.checked_sub(1)? as usize)
    }

    pub fn host_io_stats(&self) -> SemanticTransitionHostIoStats {
        let io = self.provider.host_transfer_stats();
        let metadata = self.provider.host_launch_metadata_transfer_stats();
        let observation = self.provider.final_observation_transfer_stats();
        SemanticTransitionHostIoStats {
            htod_bytes: io.htod_bytes,
            dtoh_bytes: io.dtoh_bytes,
            htod_calls: io.htod_calls,
            dtoh_calls: io.dtoh_calls,
            launch_metadata_bytes: metadata.htod_bytes,
            launch_metadata_calls: metadata.htod_calls,
            metadata_dtoh_calls: self.provider.untracked_metadata_dtoh_count(),
            observation_bytes: observation.dtoh_bytes,
            observation_calls: observation.dtoh_calls,
            session_stream_waits: self.stream_waits,
        }
    }

    pub fn root_snapshot(&mut self) -> Result<SemanticRootSnapshot, SemanticTransitionError> {
        self.ensure_quiescent()?;
        Ok(self.base_snapshot)
    }

    /// Validates the entire binding before touching resident state. The cold owner
    /// supplies a globally unique stream namespace and the acquired proposal. This
    /// is reconstruction of pending state, not publication or advancement of the
    /// canonical RNG. Rebinding after observation keeps the captured addresses.
    pub fn bind_inputs(
        &mut self,
        binding: SemanticCatalogueBinding,
        rng: SemanticRngBinding,
        inputs: &[SemanticComponentInput],
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_rebindable()?;
        if binding != self.binding() {
            return Err(SemanticTransitionError::CatalogueMismatch);
        }
        validate_bound_inputs(&self.codebooks.components, rng, inputs)?;
        self.validate_ranges()?;
        let logits: Vec<f32> = inputs
            .iter()
            .flat_map(|r| r.logits.iter().copied())
            .collect();
        let support: Vec<u8> = inputs
            .iter()
            .flat_map(|r| r.product_support.iter().copied())
            .collect();
        #[cfg(feature = "semantic-policy")]
        if self.pending_policy.is_some() {
            return Err(publication_input_error(
                "original policy snapshots cannot be replaced by raw inputs",
            ));
        }
        #[cfg(feature = "semantic-policy")]
        if self.policy.is_some() {
            self.captured = None;
            self.policy = None;
        }
        // The provider's synchronous uploader uses its setup stream. Complete it
        // before adopting allocations onto the distinct resident execution stream.
        let upload = (|| {
            self.provider
                .htod_sync_copy_into_tracked(&logits, &mut self.logits)?;
            self.provider
                .htod_sync_copy_into_tracked(&support, &mut self.support)?;
            Ok::<(), XlogError>(())
        })();
        upload.map_err(|e| {
            self.poisoned = true;
            runtime_error("input upload", e)
        })?;
        self.upload_rng_state(binding, rng)?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read_write(&self.logits);
        recorder.read_write(&self.support);
        recorder.read_write(&self.state);
        recorder.write(&self.scratch);
        recorder.write(&self.receipts);
        recorder.read(&self.device_codebooks);
        recorder.read(&self.device_components);
        // SAFETY: completed setup copies precede this ownership adoption. No work
        // escapes the supplied stream, and no output payload is initialized here.
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |_| {
            Ok::<(), XlogError>(())
        })?;
        self.stream_waits += 1;
        self.stream.synchronize().map_err(|e| {
            self.poisoned = true;
            runtime_error("input adoption wait", e)
        })?;
        self.rng = Some(rng);
        self.next_proposal = u64::from(rng.proposal);
        Ok(())
    }

    /// Takes independent device snapshots of the exact proposal's model inputs.
    /// Text logits retain all 32 rows of the original MASK matrix;
    /// both lanes read the same original row. Structural scores are
    /// produced by the pinned numerical policy inside the component loop.
    ///
    /// Parameters use `policy_layout()`. Source allocations must be tracked in
    /// this execution domain; the recorder joins their producer streams before
    /// copying. No caller-owned parameter buffer is used by subsequent replay.
    /// The five original FP64 arrays, in order, are parameter/baseline
    /// ordinary-underflow envelopes followed by parameter/text/baseline
    /// magnitude-ordinary-underflow-independent-ideal domains. They share the
    /// same snapshot; pointwise E is not replaced by domain O/U.
    /// The original cold task supplies the law for pre-draw uniform domains;
    /// an absent prospective training domain has no admissible training groups.
    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "all nine original policy operands share one snapshot"
    )]
    pub fn bind_policy(
        &mut self,
        binding: SemanticCatalogueBinding,
        rng: SemanticRngBinding,
        text_logits: &TrackedCudaSlice<f32>,
        product_support: &TrackedCudaSlice<u8>,
        parameters: &TrackedCudaSlice<f32>,
        component_baselines: &TrackedCudaSlice<f32>,
        numerical: [&TrackedCudaSlice<f64>; 5],
    ) -> Result<(), SemanticTransitionError> {
        self.bind_policy_views(
            binding,
            rng,
            text_logits.view(),
            product_support.view(),
            parameters.view(),
            component_baselines.view(),
            numerical.map(TrackedCudaSlice::view),
            None,
        )
    }

    /// Import genuine DLPack owners and snapshot one proposal's policy inputs.
    ///
    /// All tensors are contiguous CUDA storage on this session's device:
    /// F32 `[32, text_cardinality()]`, Bool8 `[policy_support_layout().1]`,
    /// F32 `[policy_layout().parameter_cells]`, and FP32 `[1, 136]` component
    /// baselines, followed by FP64 envelopes `[P,2]`, `[1,136,2]` and FP64
    /// domains `[P,4]`, `[32,V,4]`, `[1,136,4]` in `(M,O,U,I)` order, where P
    /// is the parameter extent and V is the text vocabulary. Pointwise E is
    /// distinct from domain O/U; I is independently derived on the ideal
    /// formula, never M+O+U. One original content witness
    /// authenticates all nine operands in that order. The snapshots may precede
    /// continuation binding; capture remains unavailable until both stages join.
    /// Both lanes share the original
    /// mapped MASK rows; unused capacity is not a categorical factor.
    /// Support contains only active TEXT and the structural rows in roster order;
    /// inactive TEXT has no address. The roster itself still has 136 factors.
    ///
    /// The canonical importer joins the explicit original consumer stream and
    /// checks the acquired parent's witness before the recorded device-to-device
    /// snapshot. No tensor value is read or reconstructed on the host.
    /// The caller must meet `DlpackManagedTensor::from_raw`'s producer-readiness
    /// and external-access contract; these handles confer no task/use authority.
    /// Original model/autograd owners remain the caller's separate responsibility.
    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the complete original witness and operand owners are explicit"
    )]
    pub fn bind_policy_dlpack(
        &mut self,
        lease: &SemanticPublishedLease,
        binding: SemanticCatalogueBinding,
        rng: SemanticRngBinding,
        text_logits: DlpackManagedTensor,
        product_support: DlpackManagedTensor,
        parameters: DlpackManagedTensor,
        component_baselines: DlpackManagedTensor,
        numerical: [DlpackManagedTensor; 5],
        witness: &SemanticTensorContentWitness,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        // Own all actual producers before the first fallible binding/shape check.
        // A failed handoff retains the entire set through canonical retirement.
        let mut handoff = RetainedTensorAdmission {
            inputs: Some(
                vec![
                    text_logits,
                    product_support,
                    parameters,
                    component_baselines,
                ]
                .into_iter()
                .chain(numerical)
                .collect(),
            ),
            stream: Arc::clone(self.provider.device().inner().stream()),
            ready: false,
        };
        self.ensure_rebindable()?;
        self.checked_reader(lease)?;
        self.checked_content_witness(lease, witness)?;
        if rng != self.admitted_policy_rng(lease)? {
            return Err(publication_input_error(
                "policy invocation differs from its actual acquired parent",
            ));
        }
        if binding != self.binding() {
            return Err(SemanticTransitionError::CatalogueMismatch);
        }
        if rng.stream_serial >= (1u64 << 56) {
            return Err(SemanticTransitionError::InvalidInput {
                detail: "policy stream namespace does not match the native catalogue".into(),
            });
        }
        let layout = self.policy_layout()?;
        let layouts =
            policy_numerical_producer_layouts(self.codebooks.input_cells, layout.parameter_cells)?;
        // Preserve the actual rank-two MASK matrix and each producer owner.
        // The typed importer validates original metadata; no column adapter,
        // compacted rows or replacement managed tensor is manufactured.
        let inputs = handoff
            .inputs
            .take()
            .expect("retained policy producers")
            .into_iter()
            .zip(layouts)
            .map(|(tensor, layout)| SemanticTensorInput {
                layout,
                logical_begin: 0,
                logical_end: 0,
                tensor,
                native_allocation: None,
            })
            .collect();
        self.verify_tensor_content(lease, witness, inputs, consumer_stream)?;
        let original =
            policy_source_views(&self.steps[&lease.token].content[witness.index].tensors)?;
        self.bind_policy_views(
            binding,
            rng,
            original.text_logits,
            original.product_support,
            original.parameters,
            original.component_baselines,
            original.numerical,
            Some((witness.clone(), consumer_stream)),
        )
    }

    #[cfg(feature = "semantic-policy")]
    fn allocate_policy_buffers(&self) -> Result<PolicyBuffers, SemanticTransitionError> {
        let layout = self.policy_layout()?;
        let mut reservation = self
            .provider
            .memory()
            .reserve_bytes(policy_buffer_bytes(&layout, self.codebooks.input_cells)? as u64)
            .map_err(|error| runtime_error("policy reservation", error))?;
        self.allocate_policy_buffers_reserved(&mut reservation)
    }

    #[cfg(feature = "semantic-policy")]
    fn allocate_policy_buffers_reserved(
        &self,
        reservation: &mut GpuMemoryReservation,
    ) -> Result<PolicyBuffers, SemanticTransitionError> {
        let layout = self.policy_layout()?;
        let law = self.task_objective_law().ok_or_else(|| {
            publication_input_error("uniform policy domains require the original cold task law")
        })?;
        let text_cells = 32 * TEXT_CARDINALITY;
        let pwl_cells = reservation
            .alloc::<SemanticPolicyPwlCell>(COMPONENT_COUNT)
            .map_err(|error| runtime_error("retained PWL cell allocation", error))?;
        let selected_score_vjps = reservation
            .alloc::<SemanticPolicySelectedScoreVjp>(COMPONENT_COUNT)
            .map_err(|error| runtime_error("retained selected-score VJP allocation", error))?;
        let mut allocate_adjoints = || {
            let mut allocate_numerical = |cells: usize| {
                reservation
                    .alloc::<f64>(cells)
                    .map_err(|error| runtime_error("policy adjoint numerical allocation", error))
            };
            let numerical = Arc::new(PolicyAdjointNumerical {
                roots: [
                    allocate_numerical(
                        layout
                            .parameter_cells
                            .checked_mul(2)
                            .ok_or(SemanticTransitionError::GenerationExhausted)?,
                    )?,
                    allocate_numerical(text_cells * 2)?,
                    allocate_numerical(COMPONENT_COUNT * 2)?,
                    allocate_numerical(
                        layout
                            .parameter_cells
                            .checked_mul(8)
                            .ok_or(SemanticTransitionError::GenerationExhausted)?,
                    )?,
                    allocate_numerical(text_cells * 8)?,
                    allocate_numerical(COMPONENT_COUNT * 8)?,
                ],
                recurrent_errors: allocate_numerical(layout.recurrent_cells() * 8)?,
                score_errors: allocate_numerical(layout.score_cells() * 8)?,
                coefficient_errors: allocate_numerical(COMPONENT_COUNT * 8)?,
                root_cotangents: [
                    allocate_numerical(
                        layout
                            .parameter_cells
                            .checked_mul(8)
                            .ok_or(SemanticTransitionError::GenerationExhausted)?,
                    )?,
                    allocate_numerical(text_cells * 8)?,
                    allocate_numerical(COMPONENT_COUNT * 8)?,
                ],
            });
            Ok::<_, SemanticTransitionError>(PolicyAdjointBuffers {
                numerical,
                parameters: reservation
                    .alloc::<f32>(layout.parameter_cells)
                    .map_err(|error| runtime_error("parameter adjoint allocation", error))?,
                text_logits: reservation
                    .alloc::<f32>(text_cells)
                    .map_err(|error| runtime_error("text adjoint allocation", error))?,
                component_baselines: reservation
                    .alloc::<f32>(COMPONENT_COUNT)
                    .map_err(|error| runtime_error("baseline adjoint allocation", error))?,
                recurrent: reservation
                    .alloc::<f32>(layout.recurrent_cells())
                    .map_err(|error| runtime_error("recurrent adjoint allocation", error))?,
                scores: reservation
                    .alloc::<f32>(layout.score_cells())
                    .map_err(|error| runtime_error("score adjoint allocation", error))?,
                coefficients: reservation
                    .alloc::<f64>(COMPONENT_COUNT)
                    .map_err(|error| runtime_error("cotangent snapshot allocation", error))?,
                status: reservation
                    .alloc::<u64>(1)
                    .map_err(|error| runtime_error("policy backward status allocation", error))?,
            })
        };
        let adjoints = allocate_adjoints()?;
        let temporal_adjoints = Arc::new(allocate_adjoints()?);
        let mut allocate_uniform = |cells: usize| {
            reservation
                .alloc::<f64>(cells)
                .map_err(|error| runtime_error("uniform policy domain allocation", error))
        };
        let root_cells = [layout.parameter_cells, text_cells, COMPONENT_COUNT];
        let mut roots = Vec::with_capacity(3);
        let mut outputs = Vec::with_capacity(3);
        for cells in root_cells {
            let cells = cells
                .checked_mul(8)
                .ok_or(SemanticTransitionError::GenerationExhausted)?;
            outputs.push(allocate_uniform(cells)?);
        }
        for cells in [layout.parameter_cells, TEXT_CARDINALITY, COMPONENT_COUNT] {
            roots.push(allocate_uniform(
                cells
                    .checked_mul(8)
                    .ok_or(SemanticTransitionError::GenerationExhausted)?,
            )?);
        }
        let roots: [_; 3] = roots
            .try_into()
            .unwrap_or_else(|_| unreachable!("three policy roots"));
        let outputs: [_; 3] = outputs
            .try_into()
            .unwrap_or_else(|_| unreachable!("three policy outputs"));
        let scratch = [
            allocate_uniform(layout.recurrent_cells() * 4)?,
            allocate_uniform(128 * 4)?,
            allocate_uniform(layout.score_cells() * 4)?,
            allocate_uniform(layout.recurrent_cells() * 8)?,
            allocate_uniform(layout.score_cells() * 8)?,
            allocate_uniform(COMPONENT_COUNT * 8)?,
        ];
        let status = reservation
            .alloc::<u64>(1)
            .map_err(|error| runtime_error("uniform policy status allocation", error))?;
        let work = reservation
            .alloc::<u64>(11)
            .map_err(|error| runtime_error("uniform policy work allocation", error))?;
        let descriptor = reservation
            .alloc::<PolicyUniformDescriptor>(1)
            .map_err(|error| runtime_error("uniform policy descriptor allocation", error))?;
        let initial_descriptor = PolicyUniformDescriptor {
            outputs: outputs.each_ref().map(TrackedCudaSlice::device_ptr_value),
            roots: roots.each_ref().map(TrackedCudaSlice::device_ptr_value),
            recurrent: scratch[0].device_ptr_value(),
            hidden: scratch[1].device_ptr_value(),
            scores: scratch[2].device_ptr_value(),
            recurrent_cotangents: scratch[3].device_ptr_value(),
            score_cotangents: scratch[4].device_ptr_value(),
            score_roots: scratch[5].device_ptr_value(),
            status: status.device_ptr_value(),
            work: work.device_ptr_value(),
            training_rows: self
                .task_training_domain()
                .map_or(0, SemanticTrainingDomain::record_limit),
            return_bound: law.return_bound as u64,
            loss_coefficients: [3, 6, 7, 8].map(|index| f64::from(law.coefficients[index])),
        };
        let uniform = Arc::new(PolicyUniformBuffers {
            descriptor,
            initial_descriptor,
            roots,
            outputs,
            scratch,
            status,
            work,
            execute: self
                .provider
                .device()
                .inner()
                .get_func(
                    "xlog_semantic_transition",
                    "semantic_policy_uniform_domains",
                )
                .ok_or_else(|| {
                    runtime_error("kernel lookup", "uniform policy domains unavailable")
                })?,
        });
        let mut allocate_numerical = |cells: usize| {
            reservation
                .alloc::<f64>(cells)
                .map_err(|error| runtime_error("policy numerical allocation", error))
        };
        let numerical = PolicyNumericalBuffers {
            uniform,
            parameter_errors: allocate_numerical(
                layout
                    .parameter_cells
                    .checked_mul(2)
                    .ok_or(SemanticTransitionError::GenerationExhausted)?,
            )?,
            baseline_errors: allocate_numerical(COMPONENT_COUNT * 2)?,
            parameter_domains: allocate_numerical(
                layout
                    .parameter_cells
                    .checked_mul(4)
                    .ok_or(SemanticTransitionError::GenerationExhausted)?,
            )?,
            text_domains: allocate_numerical(text_cells * 4)?,
            baseline_domains: allocate_numerical(COMPONENT_COUNT * 4)?,
            hidden_errors: allocate_numerical(128 * 3)?,
            score_errors: allocate_numerical(layout.score_cells() * 3)?,
            recurrent_errors: allocate_numerical(layout.recurrent_cells() * 3)?,
            parameter_envelopes: allocate_numerical(
                layout
                    .parameter_cells
                    .checked_mul(3)
                    .ok_or(SemanticTransitionError::GenerationExhausted)?,
            )?,
            baseline_envelopes: allocate_numerical(COMPONENT_COUNT * 3)?,
        };
        Ok(PolicyBuffers {
            numerical,
            parameters: reservation
                .alloc::<f32>(layout.parameter_cells)
                .map_err(|error| runtime_error("policy parameter allocation", error))?,
            hidden: reservation
                .alloc::<f32>(128)
                .map_err(|error| runtime_error("policy hidden allocation", error))?,
            scores: reservation
                .alloc::<f32>(layout.score_cells())
                .map_err(|error| runtime_error("policy score allocation", error))?,
            retained_scores: reservation
                .alloc::<f32>(layout.retained_score_cells())
                .map_err(|error| runtime_error("retained policy score allocation", error))?,
            final_masks: reservation
                .alloc::<u8>(self.codebooks.input_cells)
                .map_err(|error| runtime_error("retained final mask allocation", error))?,
            active_sets: reservation
                .alloc::<u8>(self.codebooks.input_cells)
                .map_err(|error| runtime_error("retained active set allocation", error))?,
            pwl_cells,
            selected_score_vjps,
            recurrent: reservation
                .alloc::<f32>(layout.recurrent_cells())
                .map_err(|error| runtime_error("policy recurrent allocation", error))?,
            text_logits: reservation
                .alloc::<f32>(text_cells)
                .map_err(|error| runtime_error("original text snapshot allocation", error))?,
            component_baselines: reservation
                .alloc::<f32>(COMPONENT_COUNT)
                .map_err(|error| runtime_error("component baseline snapshot allocation", error))?,
            adjoints: Some(adjoints),
            temporal_adjoints,
            layout,
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn prepare_step_policy_storage(
        &self,
        reservation: &mut GpuMemoryReservation,
    ) -> Result<PreparedPolicyStorage, SemanticTransitionError> {
        let buffers = self.allocate_policy_buffers_reserved(reservation)?;
        let support = reservation
            .alloc(self.codebooks.input_cells)
            .map_err(|error| runtime_error("prepared support allocation", error))?;
        let receipts = reservation
            .alloc(COMPONENT_COUNT)
            .map_err(|error| runtime_error("prepared receipt allocation", error))?;
        let state = reservation
            .alloc(1)
            .map_err(|error| runtime_error("prepared state allocation", error))?;
        Ok((buffers, support, receipts, state))
    }

    /// Retain and snapshot the original policy producers in their already
    /// reserved native branch. The snapshots are available before continuation
    /// binding on the same bank execution retains. Neither binding creates a
    /// draw; execution requires both original owners.
    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "prepared policy binding retains each typed producer and witness explicitly"
    )]
    pub fn bind_prepared_policy(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        binding: SemanticCatalogueBinding,
        text_logits: DlpackManagedTensor,
        product_support: DlpackManagedTensor,
        parameters: DlpackManagedTensor,
        component_baselines: DlpackManagedTensor,
        numerical: [DlpackManagedTensor; 5],
        witness: &SemanticTensorContentWitness,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, consumer_stream)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared policy bank must be zero or one",
            ));
        }
        if self.prepared_transition_kind(step)? != SemanticTransitionKind::Proposal {
            return Err(publication_input_error(
                "only a proposal step binds a learned policy",
            ));
        }
        if binding != self.binding() {
            return Err(SemanticTransitionError::CatalogueMismatch);
        }
        let layouts = policy_numerical_producer_layouts(
            self.codebooks.input_cells,
            self.policy_layout()?.parameter_cells,
        )?;
        let tensors = [
            text_logits,
            product_support,
            parameters,
            component_baselines,
        ]
        .into_iter()
        .chain(numerical)
        .zip(layouts)
        .map(|(tensor, layout)| SemanticTensorInput {
            layout,
            logical_begin: 0,
            logical_end: 0,
            tensor,
            native_allocation: None,
        })
        .collect();
        self.verify_prepared_tensor_content(step, witness, tensors, consumer_stream)?;
        let sources = self.steps[&step.token].content[witness.index]
            .tensors
            .clone();
        let owner = self
            .steps
            .get_mut(&step.token)
            .expect("checked original step");
        let prepared = owner.prepared.as_mut().expect("prepared policy owner");
        let branch = &mut prepared.branches[bank];
        if branch.policy.is_some() || !branch.policy_sources.is_empty() {
            return Err(publication_input_error(
                "prepared policy already owns its original invocation",
            ));
        }
        if branch.policy_buffers.is_none() {
            return Err(publication_input_error(
                "prepared policy has no unused cold allocation",
            ));
        }
        branch.policy_sources = sources;
        branch.policy_witness = Some(witness.clone());
        let sources = policy_source_views(&branch.policy_sources)?;
        enqueue_policy_snapshots(
            &self.domain,
            &mut self.poisoned,
            branch
                .policy_buffers
                .as_ref()
                .expect("checked original cold policy bank"),
            branch.support.as_ref().expect("original support bank"),
            &sources,
        )?;
        enqueue_policy_uniform_domains(
            &self.domain,
            &mut self.poisoned,
            branch
                .policy_buffers
                .as_ref()
                .expect("original policy domain bank"),
            &self.device_components,
            branch.support.as_ref().expect("original support bank"),
        )?;
        self.attach_prepared_policy_continuation(step, bank)
    }

    /// Join two independently admitted stages without allocating or replacing
    /// either original producer. Before the join, sources and cold banks remain
    /// owned by the branch and cannot be executed as a policy tape.
    #[cfg(feature = "semantic-policy")]
    fn attach_prepared_policy_continuation(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
    ) -> Result<(), SemanticTransitionError> {
        let branch = &mut self
            .steps
            .get_mut(&step.token)
            .expect("checked original step")
            .prepared
            .as_mut()
            .expect("prepared policy owner")
            .branches[bank];
        if branch.policy.is_some() || branch.policy_sources.is_empty() {
            return Ok(());
        }
        let Some(continuation) = branch.continuation.as_ref() else {
            return Ok(());
        };
        let text_binding = Arc::clone(&continuation.text_binding);
        if text_binding._witness.reader_token != step.token {
            return Err(publication_input_error(
                "prepared policy and continuation belong to different original steps",
            ));
        }
        let buffers = branch.policy_buffers.take().ok_or_else(|| {
            publication_input_error("prepared policy has no unused cold allocation")
        })?;
        branch.policy = Some(PolicyStorage {
            buffers,
            text_binding,
            _policy_witness: branch.policy_witness.clone(),
            replacement: None,
            tape_live: false,
            temporal_vjp_recorded: BTreeSet::new(),
        });
        Ok(())
    }

    /// Consume the original numerical body through the canonical policy,
    /// resolver and publication kernel, with this step's distinct late tape.
    #[cfg(feature = "semantic-policy")]
    pub fn enqueue_prepared_transition(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        if bank > 1 {
            return Err(publication_input_error(
                "prepared transition bank must be zero or one",
            ));
        }
        let kind = self.prepared_transition_kind(step)?;
        let finish = self
            .steps
            .get_mut(&step.token)
            .expect("checked original step")
            .prepared
            .as_mut()
            .expect("prepared owner")
            .model_work
            .as_mut()
            .ok_or_else(|| {
                publication_input_error("prepared transition requires original model work")
            })
            .and_then(|work| work.finish_capture(bank).map_err(publication_input_error));
        if let Err(error) = finish {
            self.poisoned = true;
            return Err(error);
        }
        let owner = &self.steps[&step.token];
        let prepared = owner.prepared.as_ref().expect("prepared transition owner");
        let branch = &prepared.branches[bank];
        if prepared.transition_recorded & (1 << bank) != 0
            || prepared.model_content_recorded & (1 << bank) == 0
            || branch.continuation.is_none()
            || (kind == SemanticTransitionKind::Proposal && branch.policy.is_none())
            || (kind != SemanticTransitionKind::Proposal && branch.policy.is_some())
            || (kind == SemanticTransitionKind::Update
                && branch
                    .model_update
                    .as_ref()
                    .is_none_or(|update| update.output.is_none()))
        {
            return Err(publication_input_error("prepared transition requires recorded branch model content, its unused original continuation, a policy only for proposals, and a bound model output for updates"));
        }
        let policy_witness = if kind == SemanticTransitionKind::Proposal {
            Some(branch.policy_witness.clone().ok_or_else(|| {
                publication_input_error("prepared transition has no original policy content")
            })?)
        } else {
            None
        };
        let continuation_witness = branch
            .continuation
            .as_ref()
            .expect("checked continuation")
            .text_binding
            ._witness
            .clone();
        if let Some(witness) = &policy_witness {
            self.record_prepared_tensor_content(step, witness, true)?;
        }
        self.record_prepared_tensor_content(step, &continuation_witness, true)?;
        let result = (|| {
            let prepared = self.steps[&step.token]
                .prepared
                .as_ref()
                .expect("retained original step");
            let branch = &prepared.branches[bank];
            branch
                .continuation
                .as_ref()
                .expect("checked original continuation")
                .enqueue(&self.domain, &mut self.poisoned)?;
            if let Some(update) = &branch.model_update {
                let training_view = prepared.training_view.as_ref().ok_or_else(|| {
                    publication_input_error("prepared update has no native training view")
                })?;
                update.enqueue_copy(
                    &self.domain,
                    &mut self.poisoned,
                    self.publication.as_ref().expect("prepared publication"),
                    &prepared.reader,
                    training_view,
                    &self.task.as_ref().expect("prepared task binding").1,
                    prepared
                        .model_work
                        .as_ref()
                        .expect("prepared model work frozen above"),
                )?;
            }
            let io = self.prepared_kernel_io(step, bank)?;
            self.validate_ranges_with(&io)?;
            let descriptor = self.descriptor_with(&io);
            let recorder = self.kernel_recorder_with(&io);
            let execute = self.execute.clone();
            enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
                // SAFETY: the same selected original buffers define both the
                // kernel arguments and every retained recorder allocation.
                unsafe {
                    execute.launch_in(
                        enqueue,
                        LaunchConfig {
                            grid_dim: (1, 1, 1),
                            block_dim: (256, 1, 1),
                            shared_mem_bytes: 0,
                        },
                        (descriptor,),
                    )
                }
                .map_err(|error| XlogError::Kernel(error.to_string()))
            })
        })();
        if result.is_err() {
            self.poisoned = true;
            return result;
        }
        let prepared = self
            .steps
            .get_mut(&step.token)
            .expect("retained original step")
            .prepared
            .as_mut()
            .expect("retained original prepared step");
        prepared.transition_recorded |= 1 << bank;
        Ok(())
    }

    /// Record the device-selected terminal drain without executing the model,
    /// continuation producer, optimizer, or training-output path.
    #[cfg(feature = "semantic-policy")]
    pub fn enqueue_prepared_drain(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        self.check_prepared_content_stream(step, self.stream.cu_stream() as u64)?;
        let prepared = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("prepared drain owner");
        if prepared.transition_recorded != PREPARED_TRANSITION_BANKS || prepared.drain_recorded {
            return Err(publication_input_error(
                "prepared drain requires its recorded requested branch and unused drain branch",
            ));
        }
        let publication = self.publication.as_ref().expect("prepared publication");
        let mut recorder = self.domain.new_strict_recorder();
        publication.record(&mut recorder);
        recorder.read(&prepared.reader);
        let arguments = (
            publication.control.device_ptr_value(),
            prepared.reader.device_ptr_value(),
        );
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: the device-selected drain uses the same acquired lease and
            // publication owner as the following canonical transition kernel.
            unsafe {
                prepared.drain_prepare.clone().launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (1, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    arguments,
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        let io = self.prepared_drain_kernel_io(step)?;
        self.validate_ranges_with(&io)?;
        let descriptor = self.descriptor_with(&io);
        let recorder = self.kernel_recorder_with(&io);
        let execute = self.execute.clone();
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: the drain descriptor retains the canonical publication,
            // task, graph arena, result, and lease owners but no model outputs.
            unsafe {
                execute.launch_in(
                    enqueue,
                    LaunchConfig {
                        grid_dim: (1, 1, 1),
                        block_dim: (256, 1, 1),
                        shared_mem_bytes: 0,
                    },
                    (descriptor,),
                )
            }
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        self.steps
            .get_mut(&step.token)
            .expect("prepared drain owner")
            .prepared
            .as_mut()
            .expect("prepared drain storage")
            .drain_recorded = true;
        Ok(())
    }

    /// Move an actually observed proposal's original banks into late backward
    /// ownership. The caller supplies coordinates from its saved native header.
    #[cfg(feature = "semantic-policy")]
    fn take_prepared_policy_tape(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        invocation: SemanticRngBinding,
        refusal: Option<SemanticTransitionRefusal>,
    ) -> Result<(), SemanticTransitionError> {
        if !Arc::ptr_eq(&step.issuer, &self.publication_issuer)
            || self
                .policy_tapes
                .iter()
                .any(|tape| tape.invocation == invocation)
        {
            return Err(publication_input_error(
                "observed prepared policy differs from its original Session or invocation",
            ));
        }
        let binding = self.binding();
        let prepared = self
            .steps
            .get_mut(&step.token)
            .and_then(|owner| owner.prepared.as_mut())
            .ok_or_else(|| {
                publication_input_error("observed prepared policy has no retained original step")
            })?;
        let transition_recorded = prepared.transition_recorded;
        let branch = prepared
            .branches
            .get_mut(bank)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if transition_recorded != PREPARED_TRANSITION_BANKS
            || branch.policy.is_none()
            || branch.support.is_none()
            || branch.receipts.is_none()
        {
            return Err(publication_input_error(
                "observed prepared policy was not recorded or has already retired",
            ));
        }
        // A captured nominal proposal may be skipped or forced to drain. Only
        // actual proposal completion creates this original backward obligation.
        branch
            .policy
            .as_mut()
            .expect("checked original policy")
            .tape_live = true;
        self.policy_tapes.push(PolicyTape {
            invocation,
            refusal,
            binding,
            policy: branch.policy.take().expect("checked original policy"),
            support: branch.support.take().expect("checked original support"),
            receipts: branch.receipts.take().expect("checked original receipts"),
            prepared_bank: Some(bank),
            origin_state: None,
            components: self.device_components.view(),
            codebooks: self.device_codebooks.view(),
        });
        Ok(())
    }

    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "one original policy snapshot carries all values and numerical owners"
    )]
    fn bind_policy_views(
        &mut self,
        binding: SemanticCatalogueBinding,
        rng: SemanticRngBinding,
        text_logits: DeviceMemoryView<f32>,
        product_support: DeviceMemoryView<u8>,
        parameters: DeviceMemoryView<f32>,
        component_baselines: DeviceMemoryView<f32>,
        numerical: [DeviceMemoryView<f64>; 5],
        policy_witness: Option<(SemanticTensorContentWitness, u64)>,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_rebindable()?;
        if binding != self.binding() {
            return Err(SemanticTransitionError::CatalogueMismatch);
        }
        let layout = self.policy_layout()?;
        if self.pending_policy.is_some() {
            return Err(publication_input_error(
                "policy already owns its original snapshots",
            ));
        }
        match (self.text_binding.as_ref(), policy_witness.as_ref()) {
            (Some(binding), _) if self.continuation_base.is_some() => {
                if rng != binding.published_parent()?.1.rng_binding()? {
                    return Err(publication_input_error(
                        "policy invocation differs from its actual acquired parent",
                    ));
                }
            }
            (None, Some((witness, _)))
                if self.admitted_transition.is_some_and(|(token, _, kind)| {
                    token == witness.reader_token && kind == SemanticTransitionKind::Proposal
                }) => {}
            _ => {
                return Err(publication_input_error(
                    "policy snapshots require their original parent witness or continuation",
                ));
            }
        }
        let text_cells = 32 * TEXT_CARDINALITY;
        let support_cells = self.codebooks.input_cells;
        if self
            .admitted_transition
            .is_none_or(|(_, _, kind)| kind != SemanticTransitionKind::Proposal)
            || self.policy_tapes.iter().any(|tape| tape.invocation == rng)
        {
            return Err(publication_input_error(
                "policy binding requires a fresh admitted proposal invocation",
            ));
        }
        if rng.stream_serial >= (1u64 << 56)
            || text_logits.len() != text_cells
            || product_support.len() != support_cells
            || parameters.len() != layout.parameter_cells
            || component_baselines.len() != COMPONENT_COUNT
        {
            return Err(SemanticTransitionError::InvalidInput {
                detail:
                    "policy input shape or stream namespace does not match the native catalogue"
                        .into(),
            });
        }
        let policy = PendingPolicyStorage {
            witness: policy_witness,
            // Reserve the next working banks before the proposal may publish.
            // Successful observation moves, rather than overwrites, all exact
            // original buffers into its late tape without fallible allocation.
            replacement: PolicyReplacement {
                support: allocate_publication(&self.provider, self.codebooks.input_cells)?,
                receipts: allocate_publication(&self.provider, COMPONENT_COUNT)?,
                state: allocate_publication(&self.provider, 1)?,
            },
            buffers: self.allocate_policy_buffers()?,
            invocation: rng,
        };
        // Changing captured pointer arguments invalidates the old executable.
        // All previous work is quiescent and no unconsumed tape can reach here.
        self.captured = None;
        self.rng = None;
        self.pending_policy = Some(policy);
        let policy = self
            .pending_policy
            .as_ref()
            .expect("policy storage installed above");
        enqueue_policy_snapshots(
            &self.domain,
            &mut self.poisoned,
            &policy.buffers,
            &self.support,
            &PolicyProducerViews {
                text_logits,
                product_support,
                parameters,
                component_baselines,
                numerical,
            },
        )?;
        enqueue_policy_uniform_domains(
            &self.domain,
            &mut self.poisoned,
            &policy.buffers,
            &self.device_components,
            &self.support,
        )?;
        let consumer_stream = policy.witness.as_ref().map(|(_, stream)| *stream);
        if let Some(stream) = consumer_stream {
            if let Err(error) = self.order_content_consumers(stream) {
                self.poisoned = true;
                return Err(error);
            }
        }
        self.attach_policy_continuation()
    }

    #[cfg(feature = "semantic-policy")]
    fn attach_policy_continuation(&mut self) -> Result<(), SemanticTransitionError> {
        let Some(snapshot) = self.pending_policy.as_ref() else {
            return Ok(());
        };
        let Some(original) = self
            .text_binding
            .as_ref()
            .filter(|_| self.continuation_base.is_some())
            .map(Arc::clone)
        else {
            return Ok(());
        };
        let rng = snapshot.invocation;
        if rng != original.published_parent()?.1.rng_binding()?
            || snapshot
                .witness
                .as_ref()
                .is_some_and(|(witness, _)| witness.reader_token != original._witness.reader_token)
        {
            return Err(publication_input_error(
                "policy snapshots and continuation belong to different original parents",
            ));
        }
        // Callback-owned originals may have changed since the early snapshot.
        // Recheck their original seal without overwriting any snapshot bytes.
        let witness = snapshot.witness.clone();
        if let Some((witness, stream)) = &witness {
            self.enqueue_content_witness(witness, *stream, true)?;
        }
        self.guard_continuation_content(&original)?;
        let snapshot = self
            .pending_policy
            .take()
            .expect("checked original policy snapshots");
        self.policy = Some(PolicyStorage {
            buffers: snapshot.buffers,
            replacement: Some(snapshot.replacement),
            _policy_witness: witness.map(|(witness, _)| witness),
            text_binding: Arc::clone(&original),
            tape_live: false,
            temporal_vjp_recorded: BTreeSet::new(),
        });
        self.validate_ranges()?;
        if let Err(error) = self.order_content_consumers(original.consumer_stream) {
            self.poisoned = true;
            return Err(error);
        }
        self.rng = Some(rng);
        self.next_proposal = u64::from(rng.proposal);
        Ok(())
    }

    /// Differentiates the selected scores after successful observation. The
    /// caller supplies one FP64 scalar cotangent per original component;
    /// advantages and importance weights are not recomputed or differentiated
    /// here. The owned FP64 snapshot stays at that precision until the selected
    /// logit adjoints enter the existing FP32 model backward.
    ///
    /// This is a terminal device operation, not another transition: forward
    /// receipts, recurrent values, semantic state and RNG are only read. The
    /// original tape's preallocated outputs cannot be overwritten by a later
    /// proposal; backward neither reserves nor allocates device memory.
    #[cfg(feature = "semantic-policy")]
    pub fn backward_policy(
        &mut self,
        invocation: SemanticRngBinding,
        score_cotangents: &TrackedCudaSlice<f64>,
    ) -> Result<SemanticPolicyGradients, SemanticTransitionError> {
        self.backward_policy_view(invocation, score_cotangents.view(), 1)
    }

    /// Consume the actual original loss's 136 FP64 selected-score cotangents.
    /// The DLPack producer is joined before validation and retained on failures;
    /// no Python-selected scores or replacement autograd leaf are introduced.
    #[cfg(feature = "semantic-policy")]
    pub fn backward_policy_dlpack(
        &mut self,
        invocation: SemanticRngBinding,
        score_cotangents: DlpackManagedTensor,
        consumer_stream: u64,
    ) -> Result<SemanticPolicyGradients, SemanticTransitionError> {
        let mut handoff = RetainedTensorAdmission {
            inputs: Some(vec![score_cotangents]),
            stream: Arc::clone(self.provider.device().inner().stream()),
            ready: false,
        };
        dlpack_consumer_stream(consumer_stream)?;
        let pointer = handoff
            .inputs
            .as_ref()
            .expect("retained cotangent producer")[0]
            .as_ptr();
        if pointer.is_null() {
            return Err(publication_input_error(
                "selected-score cotangent managed owner is null",
            ));
        }
        // SAFETY: the genuine managed owner retains the original descriptor and
        // shape/stride arrays throughout this metadata-only admission.
        let (data, bytes) = unsafe {
            policy_score_cotangent_metadata(
                &(*pointer).dl_tensor,
                self.provider.device().ordinal() as i32,
            )
        }?;
        handoff.ready = true;
        let tensor = handoff
            .inputs
            .take()
            .expect("retained cotangent producer")
            .pop()
            .expect("one cotangent");
        // SAFETY: canonical metadata validates the exact original span. The
        // column transfers, rather than replaces, its retained producer owner.
        let bytes = unsafe { CudaColumn::dlpack(data, bytes, Arc::clone(&handoff.stream), tensor) }
            .device_view();
        // SAFETY: original metadata proves the full contiguous F64 roster.
        // The continuation guard orders producer events before its device use.
        let values = unsafe { bytes.cast::<f64>() }.ok_or_else(|| {
            publication_input_error("selected-score cotangent span is not aligned F64 storage")
        })?;
        self.backward_policy_view(invocation, values, consumer_stream)
    }

    #[cfg(feature = "semantic-policy")]
    fn checked_prepared_policy_tape(
        &self,
        step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
    ) -> Result<usize, SemanticTransitionError> {
        let owner = self.checked_prepared_step(step, false)?;
        if !self
            .prepared_segment
            .as_ref()
            .is_some_and(|build| build.completed)
            || !owner
                .prepared
                .as_ref()
                .is_some_and(|prepared| prepared.observed)
        {
            return Err(publication_input_error(
                "prepared policy requires its actual completed native outcome",
            ));
        }
        self.policy_tapes
            .iter()
            .position(|tape| {
                tape.invocation == invocation
                    && tape.policy.text_binding._witness.reader_token == step.token
            })
            .ok_or_else(|| {
                publication_input_error(
                    "prepared policy has no unconsumed original tape for this step",
                )
            })
    }

    /// Completion moves the executed policy out of branch storage into its
    /// original tape. Cold observations must follow that same one-use owner.
    #[cfg(feature = "semantic-policy")]
    fn completed_prepared_policy_tape(
        &mut self,
        step: &SemanticPreparedStep,
    ) -> Result<usize, SemanticTransitionError> {
        let header_view = self
            .checked_prepared_step(step, false)?
            .inputs
            .as_ref()
            .ok_or(SemanticTransitionError::ObservationMismatch)?
            .header
            .view();
        let parent = self.publication_read(header_view)?[0];
        let index = self.checked_prepared_policy_tape(step, parent.rng_binding()?)?;
        let tape = &self.policy_tapes[index];
        // Publication banks select recorded branches. Model-weight banks
        // advance only on Update and are not the original branch selector.
        if tape.prepared_bank != Some((parent.publication_word & 1) as usize)
            || tape.refusal.is_some()
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok(index)
    }

    /// Authenticate the actual completed step and its unconsumed original tape
    /// before a binding exposes this invocation to its numerical producer.
    #[cfg(feature = "semantic-policy")]
    pub fn require_prepared_policy_invocation(
        &self,
        step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
    ) -> Result<usize, SemanticTransitionError> {
        let index = self.checked_prepared_policy_tape(step, invocation)?;
        self.policy_tapes[index]
            .prepared_bank
            .ok_or(SemanticTransitionError::ObservationMismatch)
    }

    /// Differentiate the original tape of this actually completed native step.
    #[cfg(feature = "semantic-policy")]
    pub fn backward_prepared_policy_dlpack(
        &mut self,
        step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
        score_cotangents: DlpackManagedTensor,
        consumer_stream: u64,
    ) -> Result<SemanticPolicyGradients, SemanticTransitionError> {
        self.checked_prepared_policy_tape(step, invocation)?;
        self.backward_policy_dlpack(invocation, score_cotangents, consumer_stream)
    }

    /// Differentiate one original prepared proposal from the Update step's
    /// resident actor/critic/cost objective. Call this once for every proposal
    /// invocation in the frozen segment. The kernel compares the proposal's
    /// schedule ordinal to the selected origin candidate, so all unselected
    /// invocations return graph-connected zero adjoints without host readback.
    #[cfg(feature = "semantic-policy")]
    pub fn backward_selected_prepared_policy(
        &mut self,
        step: &SemanticPreparedStep,
        update_step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
        consumer_stream: u64,
    ) -> Result<SemanticSelectedPolicyGradients, SemanticTransitionError> {
        self.ensure_quiescent()?;
        dlpack_consumer_stream(consumer_stream)?;
        let tape_index = self.checked_prepared_policy_tape(step, invocation)?;
        if let Some(refusal) = self.policy_tapes[tape_index].refusal {
            return Err(refusal.into_error());
        }
        let update_owner = self.checked_prepared_step(update_step, false)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared segment");
        if !build.completed
            || !update_owner
                .prepared
                .as_ref()
                .is_some_and(|prepared| prepared.observed)
        {
            return Err(publication_input_error(
                "selected policy backward requires the actual completed Update step",
            ));
        }
        if build.requested_kind(update_step, &self.publication_issuer)?
            != SemanticTransitionKind::Update
        {
            return Err(publication_input_error(
                "selected policy backward requires a prepared Update step",
            ));
        }
        let origin_candidate = build
            .tokens
            .iter()
            .position(|token| *token == step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let update_ordinal = build
            .tokens
            .iter()
            .position(|token| *token == update_step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if origin_candidate >= update_ordinal {
            return Err(publication_input_error(
                "selected policy backward requires a preceding proposal candidate",
            ));
        }
        let origin_candidate = u64::try_from(origin_candidate)
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        let original = Arc::clone(&self.policy_tapes[tape_index].policy.text_binding);
        self.guard_continuation_content(&original)?;
        if let Err(error) =
            self.order_step_content_inputs(original._witness.reader_token, consumer_stream)
        {
            self.poisoned = true;
            return Err(error);
        }
        let publication = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let step_aliases = Arc::clone(&self.steps[&original._witness.reader_token].aliases);
        let tape = &self.policy_tapes[tape_index];
        let policy = &tape.policy;
        let state = tape.prepared_bank.map_or(&self.state, |bank| {
            &self.steps[&original._witness.reader_token]
                .prepared
                .as_ref()
                .expect("checked prepared policy owner")
                .branches[bank]
                .state
        });
        let training = self.steps[&update_step.token]
            .prepared
            .as_ref()
            .expect("checked prepared Update owner")
            .training_view
            .as_ref()
            .ok_or_else(|| {
                publication_input_error(
                    "selected policy backward requires the Update training-view owner",
                )
            })?;
        let origin_bank = tape.prepared_bank.ok_or_else(|| {
            publication_input_error("selected policy backward requires a prepared policy bank")
        })?;
        let origin_lease = &self.steps[&original._witness.reader_token]
            .prepared
            .as_ref()
            .expect("checked prepared policy owner")
            .reader;
        let PolicyVjpRecording {
            descriptor,
            recorder,
        } = self.prepare_policy_vjp_recording(
            policy,
            policy.buffers.adjoints.as_ref().ok_or_else(|| {
                publication_input_error("original policy adjoint banks have already been consumed")
            })?,
            &tape.support,
            &tape.receipts,
            state,
            &tape.components,
            &tape.codebooks,
            PolicyVjpInput::UpdateObjective {
                training,
                origin_candidate,
                origin_lease,
                origin_bank,
            },
        )?;
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("selected policy backward stream admission", error))?;
        let execute = self.execute.clone();
        let layout = policy.layout.clone();
        let binding = tape.binding;
        let support_cells = tape.support.len();
        let baseline_snapshot = policy.component_baselines.view();
        let PolicyAdjointBuffers {
            parameters,
            text_logits,
            component_baselines,
            recurrent,
            scores,
            coefficients,
            status,
            numerical,
        } = self.policy_tapes[tape_index]
            .policy
            .buffers
            .adjoints
            .take()
            .expect("checked original adjoint banks");
        let vjp_workspace = Arc::new(PolicyVjpWorkspace {
            _numerical: Arc::clone(&numerical),
            _component_baselines: None,
            _recurrent: recurrent,
            _scores: scores,
            coefficients,
            _status: status,
            score_cotangents: None,
        });
        let output_views = [&parameters, &text_logits, &component_baselines]
            .into_iter()
            .map(|buffer| {
                // SAFETY: F32 storage has an exact, aligned byte representation.
                unsafe { buffer.view().cast::<u8>() }.expect("F32 adjoint byte view")
            });
        let step_owner = self
            .steps
            .get_mut(&original._witness.reader_token)
            .expect("retained original step");
        step_owner.adjoints.extend(output_views);
        step_owner
            .policy_vjp_workspaces
            .push(Arc::clone(&vjp_workspace));
        record_policy_vjp(
            &self.domain,
            &mut self.poisoned,
            recorder,
            execute,
            descriptor,
            &vjp_workspace.coefficients,
            None,
            Some(&baseline_snapshot),
        )?;
        if let Err(error) = self.order_content_consumers(consumer_stream) {
            self.poisoned = true;
            return Err(error);
        }
        self.policy_tapes.remove(tape_index);
        Ok(SemanticSelectedPolicyGradients {
            numerical,
            binding,
            invocation,
            layout,
            parameters,
            text_logits,
            component_baselines,
            provider: Arc::clone(&self.provider),
            step_aliases,
            publication,
            continuation: original,
            vjp_workspace,
            support_cells,
        })
    }

    #[cfg(feature = "semantic-policy")]
    /// Record one original proposal tape's complete policy contribution to the
    /// Update objective. Actor/critic/cost and supervised-edit coefficients
    /// are combined only when their authenticated rows name this exact tape.
    pub fn record_prepared_update_policy_vjp(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        update_step: &SemanticPreparedStep,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        self.record_prepared_policy_vjp(step, bank, update_step, None, false, consumer_stream)
    }

    /// Record the original prepared Proposal named by one exact frozen actor
    /// row. Unlike the single-selected compatibility path this contributes to
    /// the complete group and reserves its critic reduction slot.
    #[cfg(feature = "semantic-policy")]
    pub fn record_prepared_group_member_policy_vjp(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        update_step: &SemanticPreparedStep,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        self.record_prepared_policy_vjp(
            step,
            bank,
            update_step,
            Some((member_ordinal, member_row)),
            false,
            consumer_stream,
        )
    }

    /// Route a frozen row by native objective-group membership, never by a
    /// caller's duplicate actor/edit classification.
    #[cfg(feature = "semantic-policy")]
    pub fn record_prepared_policy_group_vjp(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        update_step: &SemanticPreparedStep,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        let actor_member = self
            .steps
            .get(&update_step.token)
            .and_then(|step| step.prepared.as_ref())
            .and_then(|step| step.training_view.as_ref())
            .ok_or_else(|| publication_input_error("Update has no selected training view"))?
            .actor_group_members()
            .iter()
            .any(|member| member.ordinal == member_ordinal);
        if actor_member {
            self.record_prepared_group_member_policy_vjp(
                step,
                bank,
                update_step,
                member_ordinal,
                member_row,
                consumer_stream,
            )
        } else {
            self.record_prepared_edit_member_policy_vjp(
                step,
                bank,
                update_step,
                member_ordinal,
                member_row,
                consumer_stream,
            )
        }
    }

    /// Record one genuine supervised-edit row outside the actor group. Actor,
    /// critic and cost terms cannot be smuggled through this edit-only path.
    #[cfg(feature = "semantic-policy")]
    pub fn record_prepared_edit_member_policy_vjp(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        update_step: &SemanticPreparedStep,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        self.record_prepared_policy_vjp(
            step,
            bank,
            update_step,
            Some((member_ordinal, member_row)),
            true,
            consumer_stream,
        )
    }

    #[cfg(feature = "semantic-policy")]
    fn record_prepared_policy_vjp(
        &mut self,
        step: &SemanticPreparedStep,
        bank: usize,
        update_step: &SemanticPreparedStep,
        member: Option<(u64, &SemanticTrainingViewRow)>,
        edit_only: bool,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        self.check_prepared_content_stream(update_step, consumer_stream)?;
        if bank > 1 {
            return Err(publication_input_error(
                "temporal policy backward requires proposal bank zero or one",
            ));
        }
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or_else(|| publication_input_error("no prepared segment is being recorded"))?;
        if build.completed
            || build.requested_kind(step, &self.publication_issuer)?
                != SemanticTransitionKind::Proposal
            || build.requested_kind(update_step, &self.publication_issuer)?
                != SemanticTransitionKind::Update
        {
            return Err(publication_input_error(
                "temporal policy backward requires a preceding Proposal and the recording Update",
            ));
        }
        let origin_candidate = build
            .tokens
            .iter()
            .position(|token| *token == step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let update_ordinal = build
            .tokens
            .iter()
            .position(|token| *token == update_step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if origin_candidate >= update_ordinal {
            return Err(publication_input_error(
                "temporal policy backward requires a preceding proposal candidate",
            ));
        }
        let origin_candidate = u64::try_from(origin_candidate)
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        let update = self.steps[&update_step.token]
            .prepared
            .as_ref()
            .expect("checked prepared Update owner");
        let update_capture_bank = update
            .model_work
            .as_ref()
            .and_then(|work| work.capture_bank)
            .ok_or_else(|| {
                publication_input_error(
                    "temporal policy backward requires an active Update bank capture",
                )
            })?;
        if update_capture_bank > 1 {
            return Err(publication_input_error(
                "temporal policy backward has an invalid Update capture bank",
            ));
        }
        let training = update.training_view.as_ref().ok_or_else(|| {
            publication_input_error("prepared Update has no selected training-view owner")
        })?;
        let member_index = if edit_only {
            None
        } else {
            member
                .map(|(ordinal, row)| training.actor_group_member_index(ordinal, row))
                .transpose()?
        };
        let edit_member = member
            .map(|(ordinal, row)| training.edit_group_member_index(ordinal, row))
            .transpose()?
            .flatten()
            .is_some();
        if let Some((ordinal, _)) = member {
            if edit_only
                && (!edit_member
                    || training
                        .actor_group_members()
                        .iter()
                        .any(|row| row.ordinal == ordinal))
            {
                return Err(publication_input_error(
                    "edit-only VJP requires a frozen edit row outside the actor group",
                ));
            }
            if update.group_critic_recorded & (1 << update_capture_bank) != 0
                || (edit_only && update.group_edit_members[update_capture_bank].contains(&ordinal))
                || (!edit_only && update.group_vjp_members[update_capture_bank].contains(&ordinal))
            {
                return Err(publication_input_error(
                    "prepared actor group member already contributed to this Update bank",
                ));
            }
        }
        let critic_term = member_index.map(|index| training.critic_term(index));
        let proposal = self.steps[&step.token]
            .prepared
            .as_ref()
            .expect("checked prepared Proposal owner");
        if proposal.transition_recorded & (1 << bank) == 0 {
            return Err(publication_input_error(
                "temporal policy backward requires the recorded original Proposal branch",
            ));
        }
        let branch = &proposal.branches[bank];
        let policy = branch.policy.as_ref().ok_or_else(|| {
            publication_input_error("prepared Proposal bank has no bound policy tape")
        })?;
        let update_capture = (update_step.token, update_capture_bank);
        if policy.temporal_vjp_recorded.contains(&update_capture) {
            return Err(publication_input_error(
                "prepared Proposal bank already recorded this Update capture's policy VJP",
            ));
        }
        let support = branch.support.as_ref().ok_or_else(|| {
            publication_input_error("prepared Proposal bank has no policy support")
        })?;
        let receipts = branch.receipts.as_ref().ok_or_else(|| {
            publication_input_error("prepared Proposal bank has no policy receipts")
        })?;
        let components = self.device_components.view();
        let codebooks = self.device_codebooks.view();
        let owner = Arc::clone(&policy.buffers.temporal_adjoints);
        let PolicyVjpRecording {
            descriptor,
            recorder,
        } = self.prepare_policy_vjp_recording(
            policy,
            &owner,
            support,
            receipts,
            &branch.state,
            &components,
            &codebooks,
            if let (Some((member_ordinal, _)), true) = (member, edit_only) {
                PolicyVjpInput::EditMember {
                    training,
                    member_ordinal,
                    origin_candidate,
                    origin_lease: &proposal.reader,
                    origin_bank: bank,
                }
            } else if let (Some((member_ordinal, _)), Some(critic_term)) = (member, &critic_term) {
                PolicyVjpInput::GroupMember {
                    training,
                    member_ordinal,
                    origin_candidate,
                    origin_lease: &proposal.reader,
                    origin_bank: bank,
                    critic_term,
                }
            } else {
                PolicyVjpInput::UpdateObjective {
                    training,
                    origin_candidate,
                    origin_lease: &proposal.reader,
                    origin_bank: bank,
                }
            },
        )?;
        let baseline_snapshot = policy.component_baselines.view();
        let layout = policy.layout.clone();
        let continuation = Arc::clone(&policy.text_binding);
        let support_cells = support.len();
        let parameters = owner.parameters.view();
        let text_logits = owner.text_logits.view();
        let component_baselines = owner.component_baselines.view();
        let step_aliases = Arc::clone(&self.steps[&step.token].aliases);
        let publication = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        record_policy_vjp(
            &self.domain,
            &mut self.poisoned,
            recorder,
            self.execute.clone(),
            descriptor,
            &owner.coefficients,
            None,
            Some(&baseline_snapshot),
        )?;
        self.steps
            .get_mut(&step.token)
            .expect("checked prepared Proposal owner")
            .prepared
            .as_mut()
            .expect("checked prepared Proposal")
            .branches[bank]
            .policy
            .as_mut()
            .expect("checked prepared policy tape")
            .temporal_vjp_recorded
            .insert(update_capture);
        if let Some((member_ordinal, _)) = member {
            let update = self
                .steps
                .get_mut(&update_step.token)
                .expect("checked prepared Update owner")
                .prepared
                .as_mut()
                .expect("checked prepared Update");
            if !edit_only {
                update.group_vjp_members[update_capture_bank].insert(member_ordinal);
            }
            if edit_member {
                update.group_edit_members[update_capture_bank].insert(member_ordinal);
            }
        }
        Ok(SemanticPreparedPolicyGradients {
            layout,
            parameters,
            text_logits,
            component_baselines,
            provider: Arc::clone(&self.provider),
            step_aliases,
            publication,
            continuation,
            owner,
            support_cells,
        })
    }

    /// Close one captured Update bank only after every frozen actor-group row
    /// contributed its original policy VJP. The device reduction reads those
    /// normalized member terms in the admitted group order, then applies the
    /// original frozen coefficient once and produces one FP32[1] scalar.
    #[cfg(feature = "semantic-policy")]
    pub fn record_prepared_group_critic(
        &mut self,
        update_step: &SemanticPreparedStep,
        bank: usize,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedGroupCritic, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        self.check_prepared_content_stream(update_step, consumer_stream)?;
        if bank > 1 {
            return Err(publication_input_error(
                "group critic requires bank zero or one",
            ));
        }
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or_else(|| publication_input_error("group critic requires a prepared segment"))?;
        if build.completed
            || build.requested_kind(update_step, &self.publication_issuer)?
                != SemanticTransitionKind::Update
        {
            return Err(publication_input_error(
                "group critic requires the recording Update step",
            ));
        }
        let prepared = self.steps[&update_step.token]
            .prepared
            .as_ref()
            .expect("checked prepared Update owner");
        if prepared
            .model_work
            .as_ref()
            .and_then(|work| work.capture_bank)
            != Some(bank)
            || prepared.group_critic_recorded & (1 << bank) != 0
        {
            return Err(publication_input_error(
                "group critic requires one active, not yet reduced Update bank",
            ));
        }
        let training = prepared.training_view.as_ref().ok_or_else(|| {
            publication_input_error("prepared Update has no selected training-view owner")
        })?;
        let actor_members = training
            .actor_group_members()
            .iter()
            .map(|member| member.ordinal)
            .collect::<BTreeSet<_>>();
        if prepared.group_vjp_members[bank] != actor_members {
            return Err(publication_input_error(
                "group critic requires every frozen actor member exactly once",
            ));
        }
        let edit_members = training
            .edit_group_members()
            .iter()
            .map(|member| member.ordinal)
            .collect::<BTreeSet<_>>();
        if prepared.group_edit_members[bank] != edit_members {
            return Err(publication_input_error(
                "group critic requires every frozen edit member exactly once",
            ));
        }
        let terms = training.critic_terms();
        let total = training.critic_total();
        let objective = training.objective();
        let count = u64::try_from(training.actor_group_members().len())
            .map_err(|_| SemanticTransitionError::GenerationExhausted)?;
        let reduce = self
            .provider
            .device()
            .inner()
            .get_func("xlog_semantic_transition", "semantic_group_critic_reduce")
            .ok_or_else(|| publication_input_error("group critic reducer is unavailable"))?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&terms);
        recorder.read(&objective);
        recorder.write(&total);
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: strict recording retains the exact group allocation and
            // the native one-cell result until the captured bank is retired.
            unsafe {
                reduce
                    .launch_in(
                        enqueue,
                        LaunchConfig {
                            grid_dim: (1, 1, 1),
                            block_dim: (1, 1, 1),
                            shared_mem_bytes: 0,
                        },
                        (
                            *terms.device_ptr(),
                            *total.device_ptr(),
                            count,
                            *objective.device_ptr(),
                        ),
                    )
                    .map_err(|error| XlogError::Kernel(format!("group critic reduction: {error}")))
            }
        })?;
        self.steps
            .get_mut(&update_step.token)
            .expect("checked prepared Update owner")
            .prepared
            .as_mut()
            .expect("checked prepared Update")
            .group_critic_recorded |= 1 << bank;
        Ok(SemanticPreparedGroupCritic {
            value: total,
            provider: Arc::clone(&self.provider),
            step_aliases: Arc::clone(&self.steps[&update_step.token].aliases),
            publication: Arc::clone(
                self.publication
                    .as_ref()
                    .ok_or(SemanticTransitionError::NotBound)?,
            ),
        })
    }

    #[cfg(feature = "semantic-policy")]
    pub fn require_recorded_group_critic(
        &self,
        update_step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        let step = self.checked_prepared_step(update_step, false)?;
        let prepared = step.prepared.as_ref().expect("checked prepared owner");
        if !self
            .prepared_segment
            .as_ref()
            .is_some_and(|build| build.completed)
            || prepared.training_view.is_none()
            || prepared.group_critic_recorded != 0b11
            || !prepared.group_update_published
        {
            return Err(publication_input_error(
                "retained group member requires completed execution of both full-group Update banks",
            ));
        }
        Ok(())
    }

    /// Prove that a captured Update has completed without publication. A
    /// retained source tape may then be retired without claiming a policy VJP.
    #[cfg(feature = "semantic-policy")]
    pub fn require_completed_unpublished_group_update(
        &self,
        update_step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        let step = self.checked_prepared_step(update_step, false)?;
        let build = self
            .prepared_segment
            .as_ref()
            .ok_or(SemanticTransitionError::NotBound)?;
        if !build.completed
            || build.requested_kind(update_step, &self.publication_issuer)?
                != SemanticTransitionKind::Update
            || step
                .prepared
                .as_ref()
                .expect("checked prepared owner")
                .group_update_published
        {
            return Err(publication_input_error(
                "retained replay requires a completed Update that did not publish",
            ));
        }
        Ok(())
    }

    /// Prove that the target executable and every prepared step owner have
    /// retired. A retained source graph cannot be released merely because the
    /// target's one-shot launch completed: the executable still holds its
    /// captured pointers until full segment retirement.
    #[cfg(feature = "semantic-policy")]
    pub fn require_retired_prepared_step(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<(), SemanticTransitionError> {
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        if !Arc::ptr_eq(&step.issuer, &self.publication_issuer)
            || self.prepared_segment.is_some()
            || self.captured.is_some()
            || self.pending
            || !self.prepared_resources.is_empty()
            || self.steps.contains_key(&step.token)
        {
            return Err(publication_input_error(
                "retained source requires completed retirement of its target segment",
            ));
        }
        Ok(())
    }

    /// Differentiate one independently restored original Proposal into this
    /// Update's graph. The child Session retains its published reader, tape,
    /// model outputs and original allocations through both captured banks.
    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the frozen target and original published invocation have distinct owners"
    )]
    pub fn record_imported_group_member_policy_vjp(
        &mut self,
        update_step: &SemanticPreparedStep,
        bank: usize,
        source: &mut SemanticTransitionSession,
        source_lease: &SemanticPublishedLease,
        invocation: SemanticRngBinding,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        self.record_imported_policy_vjp(
            update_step,
            bank,
            source,
            source_lease,
            invocation,
            member_ordinal,
            member_row,
            false,
            consumer_stream,
        )
    }

    /// Dispatch an independently restored row through the exact frozen native
    /// actor/edit membership; a nonmember cannot acquire a gradient root.
    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the frozen target and original published invocation have distinct owners"
    )]
    pub fn record_imported_policy_group_vjp(
        &mut self,
        update_step: &SemanticPreparedStep,
        bank: usize,
        source: &mut SemanticTransitionSession,
        source_lease: &SemanticPublishedLease,
        invocation: SemanticRngBinding,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        let actor_member = self
            .steps
            .get(&update_step.token)
            .and_then(|step| step.prepared.as_ref())
            .and_then(|step| step.training_view.as_ref())
            .ok_or_else(|| publication_input_error("Update has no selected training view"))?
            .actor_group_members()
            .iter()
            .any(|member| member.ordinal == member_ordinal);
        if actor_member {
            self.record_imported_group_member_policy_vjp(
                update_step,
                bank,
                source,
                source_lease,
                invocation,
                member_ordinal,
                member_row,
                consumer_stream,
            )
        } else {
            self.record_imported_edit_member_policy_vjp(
                update_step,
                bank,
                source,
                source_lease,
                invocation,
                member_ordinal,
                member_row,
                consumer_stream,
            )
        }
    }

    /// Record a historical supervised-edit row that is not an actor member.
    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the frozen target and original published invocation have distinct owners"
    )]
    pub fn record_imported_edit_member_policy_vjp(
        &mut self,
        update_step: &SemanticPreparedStep,
        bank: usize,
        source: &mut SemanticTransitionSession,
        source_lease: &SemanticPublishedLease,
        invocation: SemanticRngBinding,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        self.record_imported_policy_vjp(
            update_step,
            bank,
            source,
            source_lease,
            invocation,
            member_ordinal,
            member_row,
            true,
            consumer_stream,
        )
    }

    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "the frozen target, original invocation and exact row are independent owners"
    )]
    fn record_imported_policy_vjp(
        &mut self,
        update_step: &SemanticPreparedStep,
        bank: usize,
        source: &mut SemanticTransitionSession,
        source_lease: &SemanticPublishedLease,
        invocation: SemanticRngBinding,
        member_ordinal: u64,
        member_row: &SemanticTrainingViewRow,
        edit_only: bool,
        consumer_stream: u64,
    ) -> Result<SemanticPreparedPolicyGradients, SemanticTransitionError> {
        dlpack_consumer_stream(consumer_stream)?;
        self.check_prepared_content_stream(update_step, consumer_stream)?;
        source.ensure_quiescent()?;
        if bank > 1
            || Arc::ptr_eq(&self.publication_issuer, &source.publication_issuer)
            || self.provider.device().ordinal() != source.provider.device().ordinal()
            || self.task_content() != source.task_content()
            || self.task_content().is_none()
            || self.task_scoring_law_identity()? != source.task_scoring_law_identity()?
        {
            return Err(publication_input_error(
                "imported group member requires a distinct original Session on the same bound task and device",
            ));
        }
        let build = self.prepared_segment.as_ref().ok_or_else(|| {
            publication_input_error("imported group member requires a prepared segment")
        })?;
        if build.completed
            || build.requested_kind(update_step, &self.publication_issuer)?
                != SemanticTransitionKind::Update
        {
            return Err(publication_input_error(
                "imported group member requires the recording Update step",
            ));
        }
        let prepared = self.steps[&update_step.token]
            .prepared
            .as_ref()
            .expect("checked prepared Update owner");
        if prepared
            .model_work
            .as_ref()
            .and_then(|work| work.capture_bank)
            != Some(bank)
            || prepared.group_critic_recorded & (1 << bank) != 0
            || (edit_only && prepared.group_edit_members[bank].contains(&member_ordinal))
            || (!edit_only && prepared.group_vjp_members[bank].contains(&member_ordinal))
        {
            return Err(publication_input_error(
                "imported group member requires an unused active Update bank slot",
            ));
        }
        let training = prepared.training_view.as_ref().ok_or_else(|| {
            publication_input_error("prepared Update has no selected training-view owner")
        })?;
        let member_index = if edit_only {
            None
        } else {
            Some(training.actor_group_member_index(member_ordinal, member_row)?)
        };
        let edit_member = training
            .edit_group_member_index(member_ordinal, member_row)?
            .is_some();
        if edit_only
            && (!edit_member
                || training
                    .actor_group_members()
                    .iter()
                    .any(|row| row.ordinal == member_ordinal))
        {
            return Err(publication_input_error(
                "edit-only VJP requires a frozen edit row outside the actor group",
            ));
        }
        let critic_term = member_index.map(|index| training.critic_term(index));
        let source_index = source
            .policy_tapes
            .iter()
            .position(|tape| tape.invocation == invocation)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let continuation = Arc::clone(&source.policy_tapes[source_index].policy.text_binding);
        source.checked_content_witness(source_lease, &continuation._witness)?;
        source.guard_continuation_content(&continuation)?;
        let reader = source.checked_reader(source_lease)?;
        let tape = &source.policy_tapes[source_index];
        if tape.refusal.is_some() || tape.prepared_bank.is_some() {
            return Err(publication_input_error(
                "imported group member requires its successful published policy tape",
            ));
        }
        let state = tape.origin_state.as_ref().ok_or_else(|| {
            publication_input_error("imported group member has no original published state")
        })?;
        let owner = Arc::clone(&tape.policy.buffers.temporal_adjoints);
        let PolicyVjpRecording {
            descriptor,
            recorder,
        } = self.prepare_policy_vjp_recording(
            &tape.policy,
            &owner,
            &tape.support,
            &tape.receipts,
            state,
            &tape.components,
            &tape.codebooks,
            if let Some(critic_term) = &critic_term {
                PolicyVjpInput::GroupMember {
                    training,
                    member_ordinal,
                    origin_candidate: u64::MAX,
                    origin_lease: &reader.device,
                    origin_bank: (source_lease.header.publication_word & 1) as usize,
                    critic_term,
                }
            } else {
                PolicyVjpInput::EditMember {
                    training,
                    member_ordinal,
                    origin_candidate: u64::MAX,
                    origin_lease: &reader.device,
                    origin_bank: (source_lease.header.publication_word & 1) as usize,
                }
            },
        )?;
        let baseline_snapshot = tape.policy.component_baselines.view();
        let layout = tape.policy.layout.clone();
        let continuation = Arc::clone(&tape.policy.text_binding);
        let support_cells = tape.support.len();
        let parameters = owner.parameters.view();
        let text_logits = owner.text_logits.view();
        let component_baselines = owner.component_baselines.view();
        let step_aliases = Arc::clone(&source.steps[&source_lease.token].aliases);
        let publication = Arc::clone(
            source
                .publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        record_policy_vjp(
            &self.domain,
            &mut self.poisoned,
            recorder,
            self.execute.clone(),
            descriptor,
            &owner.coefficients,
            None,
            Some(&baseline_snapshot),
        )?;
        let update = self
            .steps
            .get_mut(&update_step.token)
            .expect("checked prepared Update owner")
            .prepared
            .as_mut()
            .expect("checked prepared Update");
        if !edit_only {
            update.group_vjp_members[bank].insert(member_ordinal);
        }
        if edit_member {
            update.group_edit_members[bank].insert(member_ordinal);
        }
        update.group_imported_vjp_members[bank].insert(member_ordinal);
        Ok(SemanticPreparedPolicyGradients {
            layout,
            parameters,
            text_logits,
            component_baselines,
            provider: Arc::clone(&source.provider),
            step_aliases,
            publication,
            continuation,
            owner,
            support_cells,
        })
    }

    #[cfg(feature = "semantic-policy")]
    pub fn finish_prepared_policy_invocation(
        &mut self,
        step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let index = self.checked_prepared_policy_tape(step, invocation)?;
        self.finish_policy_tape(index, consumer_stream)
    }

    /// Retire a completed published training invocation whose original policy
    /// tape was already differentiated inside both branches of this exact
    /// prepared Update capture. This never records or launches another VJP.
    #[cfg(feature = "semantic-policy")]
    pub fn finish_recorded_training_policy_invocation(
        &mut self,
        step: &SemanticPreparedStep,
        update_step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let index = self.checked_prepared_policy_tape(step, invocation)?;
        let update_owner = self.checked_prepared_step(update_step, false)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked prepared segment");
        if !build.completed
            || !update_owner
                .prepared
                .as_ref()
                .is_some_and(|prepared| prepared.observed)
            || build.requested_kind(update_step, &self.publication_issuer)?
                != SemanticTransitionKind::Update
        {
            return Err(publication_input_error(
                "recorded training completion requires its actual completed Update step",
            ));
        }
        let proposal_ordinal = build
            .tokens
            .iter()
            .position(|token| *token == step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let update_ordinal = build
            .tokens
            .iter()
            .position(|token| *token == update_step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if proposal_ordinal >= update_ordinal {
            return Err(publication_input_error(
                "recorded training completion requires a preceding Proposal step",
            ));
        }
        let tape = &self.policy_tapes[index];
        if tape.refusal.is_some()
            || !(0..2).all(|bank| {
                tape.policy
                    .temporal_vjp_recorded
                    .contains(&(update_step.token, bank))
            })
        {
            return Err(publication_input_error(
                "published training completion requires the exact Update VJP in both captured banks",
            ));
        }
        self.finish_policy_tape(index, consumer_stream)
    }

    /// Retire a published local Proposal that did not contribute a VJP to the
    /// complete frozen Update group. Both critic reductions prove that every
    /// frozen actor and edit member was accounted for by its actual tape.
    #[cfg(feature = "semantic-policy")]
    pub fn finish_unselected_recorded_training_policy_invocation(
        &mut self,
        step: &SemanticPreparedStep,
        update_step: &SemanticPreparedStep,
        invocation: SemanticRngBinding,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        let update_published = self
            .checked_prepared_step(update_step, false)?
            .prepared
            .as_ref()
            .expect("checked prepared owner")
            .group_update_published;
        if update_published {
            self.require_recorded_group_critic(update_step)?;
        } else {
            self.require_completed_unpublished_group_update(update_step)?;
        }
        let index = self.checked_prepared_policy_tape(step, invocation)?;
        let build = self
            .prepared_segment
            .as_ref()
            .expect("checked completed prepared segment");
        if build.requested_kind(step, &self.publication_issuer)? != SemanticTransitionKind::Proposal
            || build.requested_kind(update_step, &self.publication_issuer)?
                != SemanticTransitionKind::Update
        {
            return Err(publication_input_error(
                "unselected training completion requires its actual Proposal and Update steps",
            ));
        }
        let proposal_ordinal = build
            .tokens
            .iter()
            .position(|token| *token == step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let update_ordinal = build
            .tokens
            .iter()
            .position(|token| *token == update_step.token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if proposal_ordinal >= update_ordinal
            || self.policy_tapes[index].refusal.is_some()
            || !self.policy_tapes[index]
                .policy
                .temporal_vjp_recorded
                .is_empty()
        {
            return Err(publication_input_error(
                "unselected training completion requires an earlier published Proposal with no recorded Update VJP",
            ));
        }
        self.finish_policy_tape(index, consumer_stream)
    }

    /// Retire an exact values-only invocation after the caller's final device
    /// use. This does not differentiate, reacquire a parent, or release readers.
    /// Final step release remains the cold completion boundary.
    #[cfg(feature = "semantic-policy")]
    pub fn finish_policy_invocation(
        &mut self,
        lease: &SemanticPublishedLease,
        invocation: SemanticRngBinding,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        self.checked_step(lease)?;
        dlpack_consumer_stream(consumer_stream)?;
        let index = self
            .policy_tapes
            .iter()
            .position(|tape| tape.invocation == invocation)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let original = Arc::clone(&self.policy_tapes[index].policy.text_binding);
        self.checked_content_witness(lease, &original._witness)?;
        self.finish_policy_tape(index, consumer_stream)
    }

    #[cfg(feature = "semantic-policy")]
    fn finish_policy_tape(
        &mut self,
        index: usize,
        consumer_stream: u64,
    ) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        dlpack_consumer_stream(consumer_stream)?;
        let original = Arc::clone(&self.policy_tapes[index].policy.text_binding);
        let result = (|| {
            self.order_step_content_inputs(original._witness.reader_token, consumer_stream)?;
            self.guard_continuation_content(&original)?;
            self.order_content_consumers(consumer_stream)
        })();
        if let Err(error) = result {
            self.poisoned = true;
            return Err(error);
        }
        self.policy_tapes.remove(index);
        Ok(())
    }

    #[cfg(feature = "semantic-policy")]
    #[expect(
        clippy::too_many_arguments,
        reason = "policy VJP recording retains each native owner explicitly"
    )]
    fn prepare_policy_vjp_recording(
        &self,
        policy: &PolicyStorage,
        adjoints: &PolicyAdjointBuffers,
        support: &TrackedCudaSlice<u8>,
        receipts: &TrackedCudaSlice<SemanticTransitionReceipt>,
        state: &TrackedCudaSlice<DeviceState>,
        components: &DeviceMemoryView<SemanticComponent>,
        codebooks: &DeviceMemoryView<u64>,
        input: PolicyVjpInput<'_>,
    ) -> Result<PolicyVjpRecording, SemanticTransitionError> {
        if let PolicyVjpInput::External(score_cotangents) = input {
            if score_cotangents.len() != COMPONENT_COUNT {
                return Err(SemanticTransitionError::InvalidInput {
                    detail: "selected-score cotangents must follow the complete component roster"
                        .into(),
                });
            }
        }
        let PolicyAdjointBuffers {
            parameters,
            text_logits,
            component_baselines,
            recurrent,
            scores,
            coefficients,
            status,
            numerical,
        } = adjoints;
        let io = TransitionKernelIo {
            logits: &policy.text_logits,
            support,
            receipts,
            state,
            policy: Some(policy),
            text: Some(&policy.text_binding),
            lease: None,
            model_work: None,
            model_update: None,
            replay_custody: None,
            training_selection: None,
        };
        let task = match input {
            PolicyVjpInput::External(_) => None,
            PolicyVjpInput::UpdateObjective { training, .. }
            | PolicyVjpInput::GroupMember { training, .. }
            | PolicyVjpInput::EditMember { training, .. } => {
                if matches!(input, PolicyVjpInput::UpdateObjective { .. })
                    && training.actor_group_member_count() != 1
                {
                    return Err(publication_input_error(
                        "single-proposal policy backward cannot represent the complete actor group",
                    ));
                }
                let (binding, device) = self.task.as_ref().ok_or_else(|| {
                    publication_input_error(
                        "Update policy backward requires the bound semantic task ground",
                    )
                })?;
                if binding.goal_witness().is_none() {
                    return Err(publication_input_error(
                        "Update policy backward requires the bound semantic goal closure",
                    ));
                }
                Some(device)
            }
        };
        let mut descriptor = self.descriptor_with(&io);
        descriptor.components = *components.device_ptr();
        descriptor.codebooks = *codebooks.device_ptr();
        descriptor.publication = PublicationCommand::default();
        let (
            selection,
            objective,
            objective_groups,
            objective_group_members,
            roster_rows,
            origin_candidate,
            origin_lease,
            origin_bank,
            mode,
            member_ordinal,
            critic_term,
        ) = match input {
            PolicyVjpInput::External(_) => (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
            PolicyVjpInput::UpdateObjective {
                training,
                origin_candidate,
                origin_lease,
                origin_bank,
            } => (
                *training.selection().device_ptr(),
                *training.objective().device_ptr(),
                *training.objective_groups().device_ptr(),
                *training.objective_group_members().device_ptr(),
                *training.roster_rows().device_ptr(),
                origin_candidate,
                origin_lease.device_ptr_value(),
                origin_bank as u64,
                1,
                0,
                0,
            ),
            PolicyVjpInput::GroupMember {
                training,
                member_ordinal,
                origin_candidate,
                origin_lease,
                origin_bank,
                critic_term,
            } => (
                *training.selection().device_ptr(),
                *training.objective().device_ptr(),
                *training.objective_groups().device_ptr(),
                *training.objective_group_members().device_ptr(),
                *training.roster_rows().device_ptr(),
                origin_candidate,
                origin_lease.device_ptr_value(),
                origin_bank as u64,
                2,
                member_ordinal,
                *critic_term.device_ptr(),
            ),
            PolicyVjpInput::EditMember {
                training,
                member_ordinal,
                origin_candidate,
                origin_lease,
                origin_bank,
            } => (
                *training.selection().device_ptr(),
                *training.objective().device_ptr(),
                *training.objective_groups().device_ptr(),
                *training.objective_group_members().device_ptr(),
                *training.roster_rows().device_ptr(),
                origin_candidate,
                origin_lease.device_ptr_value(),
                origin_bank as u64,
                3,
                member_ordinal,
                0,
            ),
        };
        descriptor.backward = PolicyBackward {
            numerical: numerical.descriptor(),
            cotangents: coefficients.device_ptr_value(),
            parameters: parameters.device_ptr_value(),
            text: text_logits.device_ptr_value(),
            baselines: component_baselines.device_ptr_value(),
            recurrent: recurrent.device_ptr_value(),
            scores: scores.device_ptr_value(),
            status: status.device_ptr_value(),
            parameter_cells: policy.layout.parameter_cells as u64,
            text_cells: policy.text_logits.len() as u64,
            selection,
            objective,
            objective_groups,
            objective_group_members,
            roster_rows,
            origin_candidate,
            origin_lease,
            origin_bank,
            mode,
            member_ordinal,
            critic_term,
        };
        self.validate_ranges_with(&io)?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(support);
        recorder.read(receipts);
        recorder.read(codebooks);
        recorder.read(components);
        recorder.read(&policy.parameters);
        recorder.read(&policy.recurrent);
        recorder.read(&policy.text_logits);
        recorder.read(&policy.component_baselines);
        policy.numerical.record(&mut recorder);
        policy.text_binding.record(&mut recorder);
        match input {
            PolicyVjpInput::External(score_cotangents) => {
                recorder.read(score_cotangents);
            }
            PolicyVjpInput::UpdateObjective {
                training,
                origin_lease,
                ..
            }
            | PolicyVjpInput::GroupMember {
                training,
                origin_lease,
                ..
            }
            | PolicyVjpInput::EditMember {
                training,
                origin_lease,
                ..
            } => {
                recorder.read(&training.selection());
                recorder.read(&training.objective());
                recorder.read(&training.objective_groups());
                recorder.read(&training.objective_group_members());
                recorder.read(&training.roster_rows());
                recorder.read(state);
                recorder.read(origin_lease);
                recorder.read(task.expect("validated Update task ground"));
            }
        }
        if let PolicyVjpInput::GroupMember { critic_term, .. } = input {
            recorder.write(critic_term);
        }
        recorder.write(&self.scratch);
        recorder.write(&policy.hidden);
        recorder.write(&policy.scores);
        for buffer in [
            parameters,
            text_logits,
            component_baselines,
            recurrent,
            scores,
        ] {
            recorder.write(buffer);
        }
        recorder.write(coefficients);
        recorder.write(status);
        for buffer in numerical.buffers() {
            recorder.write(buffer);
        }
        Ok(PolicyVjpRecording {
            descriptor,
            recorder,
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn backward_policy_view(
        &mut self,
        invocation: SemanticRngBinding,
        score_cotangents: DeviceMemoryView<f64>,
        consumer_stream: u64,
    ) -> Result<SemanticPolicyGradients, SemanticTransitionError> {
        self.ensure_quiescent()?;
        dlpack_consumer_stream(consumer_stream)?;
        let tape_index = self
            .policy_tapes
            .iter()
            .position(|tape| tape.invocation == invocation)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if let Some(refusal) = self.policy_tapes[tape_index].refusal {
            return Err(refusal.into_error());
        }
        let original = Arc::clone(&self.policy_tapes[tape_index].policy.text_binding);
        self.guard_continuation_content(&original)?;
        if let Err(error) =
            self.order_step_content_inputs(original._witness.reader_token, consumer_stream)
        {
            self.poisoned = true;
            return Err(error);
        }
        let publication = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let step_aliases = Arc::clone(&self.steps[&original._witness.reader_token].aliases);
        let tape = &self.policy_tapes[tape_index];
        let policy = &tape.policy;
        let state = if let Some(bank) = tape.prepared_bank {
            &self.steps[&original._witness.reader_token]
                .prepared
                .as_ref()
                .expect("retained prepared policy step")
                .branches[bank]
                .state
        } else {
            tape.origin_state
                .as_ref()
                .expect("ordinary policy tape retains its original state")
        };
        let PolicyVjpRecording {
            descriptor,
            recorder,
        } = self.prepare_policy_vjp_recording(
            policy,
            policy.buffers.adjoints.as_ref().ok_or_else(|| {
                publication_input_error("original policy adjoint banks have already been consumed")
            })?,
            &tape.support,
            &tape.receipts,
            state,
            &tape.components,
            &tape.codebooks,
            PolicyVjpInput::External(&score_cotangents),
        )?;
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|e| runtime_error("policy backward stream admission", e))?;
        let execute = self.execute.clone();
        let layout = policy.layout.clone();
        let binding = tape.binding;
        let support_cells = tape.support.len();
        // Consume only after every fallible admission check. The recorder owns
        // the scratch banks through execution; exported outputs retain their
        // original step until the final consumer-stream join.
        let PolicyAdjointBuffers {
            parameters,
            text_logits,
            component_baselines,
            recurrent,
            scores,
            coefficients,
            status,
            numerical,
        } = self.policy_tapes[tape_index]
            .policy
            .buffers
            .adjoints
            .take()
            .expect("checked original adjoint banks");
        let vjp_workspace = Arc::new(PolicyVjpWorkspace {
            _component_baselines: None,
            _numerical: Arc::clone(&numerical),
            _recurrent: recurrent,
            _scores: scores,
            coefficients,
            _status: status,
            score_cotangents: Some(score_cotangents),
        });
        // A capsule can be deleted before its consumer finishes. The original
        // step keeps the actual outputs until its final consumer-stream join,
        // without keeping a witness (which would create a release cycle).
        let output_views = [&parameters, &text_logits, &component_baselines]
            .into_iter()
            .map(|buffer| {
                // SAFETY: F32 storage has an exact, aligned byte representation.
                unsafe { buffer.view().cast::<u8>() }.expect("F32 adjoint byte view")
            });
        let step_owner = self
            .steps
            .get_mut(&original._witness.reader_token)
            .expect("retained original step");
        step_owner.adjoints.extend(output_views);
        step_owner
            .policy_vjp_workspaces
            .push(Arc::clone(&vjp_workspace));
        record_policy_vjp(
            &self.domain,
            &mut self.poisoned,
            recorder,
            execute,
            descriptor,
            &vjp_workspace.coefficients,
            vjp_workspace.score_cotangents.as_ref(),
            None,
        )?;
        if let Err(error) = self.order_content_consumers(consumer_stream) {
            self.poisoned = true;
            return Err(error);
        }
        self.policy_tapes.remove(tape_index);
        Ok(SemanticPolicyGradients {
            component_baselines,
            numerical,
            binding,
            invocation,
            layout,
            parameters,
            text_logits,
            provider: Arc::clone(&self.provider),
            step_aliases,
            publication,
            continuation: original,
            vjp_workspace,
            support_cells,
        })
    }

    // Only construction and fresh native restoration may initialize these
    // private immutable allocations. Proposal tapes keep views of the same bytes.
    fn upload_cold_codebooks(&mut self) -> Result<(), SemanticTransitionError> {
        let upload = (|| {
            self.provider
                .htod_sync_copy_into_tracked(&self.codebooks.words, &mut self.device_codebooks)?;
            self.provider.htod_sync_copy_into_tracked(
                &self.codebooks.components,
                &mut self.device_components,
            )
        })();
        upload.map_err(|error| {
            self.poisoned = true;
            runtime_error("cold codebook upload", error)
        })
    }

    fn upload_rng_state(
        &mut self,
        binding: SemanticCatalogueBinding,
        rng: SemanticRngBinding,
    ) -> Result<(), SemanticTransitionError> {
        let state = DeviceState {
            model_generation: rng.model_generation,
            family_id: u32::from(rng.family_id),
            stream_serial: rng.stream_serial,
            next_proposal: u64::from(rng.proposal),
            catalogue_generation: binding.generation,
            catalogue_digest: Identity256::from_bytes(CATALOGUE_DIGEST),
            binding_digest: binding.digest,
            ..DeviceState::default()
        };
        let upload = self
            .provider
            .htod_sync_copy_into_tracked(&[state], &mut self.state);
        upload.map_err(|e| {
            self.poisoned = true;
            runtime_error("RNG state upload", e)
        })
    }

    pub fn capture(&mut self) -> Result<(), SemanticTransitionError> {
        self.ensure_rebindable()?;
        if self.publication.is_some()
            && (self.continuation_base.is_none()
                || self
                    .admitted_transition
                    .is_none_or(|(_, word, _)| Some(word) != self.continuation_base))
        {
            return Err(publication_input_error(
                "publication capture requires the admitted acquired-parent continuation",
            ));
        }
        if self.rng.is_none() {
            return Err(SemanticTransitionError::NotBound);
        }
        self.validate_ranges()?;
        let descriptor = self.descriptor();
        let execute = self.execute.clone();
        let recorder = self.kernel_recorder();
        self.graph.enter_transition();
        // Remain poisoned through EndCapture and instantiation, including unwind.
        // Admission inside capture transfers the actual owners to the graph.
        self.poisoned = true;
        let captured =
            CapturedCudaGraph::capture_on_stream_retaining(&self.stream, Vec::new(), || {
                // SAFETY: exact ABI, recorded disjoint allocations and bound stream.
                let enqueued = unsafe {
                    self.domain.enqueue(recorder, |enqueue| {
                        execute
                            .launch_in(
                                enqueue,
                                LaunchConfig {
                                    grid_dim: (1, 1, 1),
                                    block_dim: (256, 1, 1),
                                    shared_mem_bytes: 0,
                                },
                                (descriptor,),
                            )
                            .map_err(|error| XlogError::Kernel(error.to_string()))
                    })
                }
                .map_err(LaunchEnqueueError::into_xlog_error)?;
                enqueued.commit().map_err(|error| {
                    XlogError::Kernel(format!("semantic transition capture commit: {error}"))
                })
            })
            .map_err(|error| runtime_error("capture", error))?;
        self.captured = Some(captured);
        self.poisoned = false;
        Ok(())
    }

    /// Nonblocking replay. All 136 distributions and RNG blocks execute on device.
    pub fn launch(&mut self) -> Result<(), SemanticTransitionError> {
        self.ensure_rebindable()?;
        if let Some(binding) = self.text_binding.as_ref().map(Arc::clone) {
            self.guard_continuation_content(&binding)?;
        }
        let graph = self
            .captured
            .as_ref()
            .ok_or(SemanticTransitionError::NotCaptured)?;
        if self.next_proposal > u64::from(u32::MAX) {
            return Err(SemanticTransitionError::GenerationExhausted);
        }
        let recorder = self.kernel_recorder();
        // SAFETY: every captured allocation is registered, owned, and cannot be
        // rebound or observed until terminal completion. Graph has no host nodes.
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |stream| {
            graph.launch_in(stream)
        })?;
        self.pending = true;
        #[cfg(feature = "semantic-policy")]
        if let Some(policy) = &mut self.policy {
            policy.tape_live = true;
        }
        Ok(())
    }

    /// Waits for completion, copies the typed bank into pinned memory, then observes
    /// the actual immutable hypergraph root. Unreconciled failures poison reuse;
    /// verified ordinary refusals retain the original invocation for finalization.
    pub fn observe(
        &mut self,
        expected_proposal: u32,
    ) -> Result<SemanticTransitionOutcome, SemanticTransitionError> {
        if self.is_poisoned() {
            return Err(SemanticTransitionError::Poisoned);
        }
        if !self.pending {
            return Err(SemanticTransitionError::NoPendingLaunch);
        }
        // Successful observation advances the session RNG. The original tape
        // must keep the invocation that produced its retained receipts.
        #[cfg(feature = "semantic-policy")]
        let policy_invocation = self.rng;
        let result = self.observe_terminal(expected_proposal);
        if result.is_err() {
            self.poisoned = true;
        } else {
            self.pending = false;
            #[cfg(feature = "semantic-policy")]
            if let Err(error) = self.retain_policy_tape(
                policy_invocation,
                match &result {
                    Ok(SemanticTransitionOutcome::Refused(refusal)) => Some(*refusal),
                    _ => None,
                },
            ) {
                self.poisoned = true;
                return Err(error);
            }
            self.task_observed = self.task.is_some() && self.publication.is_none();
            if self.publication.is_some() {
                self.continuation_base = None;
                self.admitted_transition = None;
                self.text_binding = None;
            }
        }
        result
    }

    #[cfg(feature = "semantic-policy")]
    fn retain_policy_tape(
        &mut self,
        invocation: Option<SemanticRngBinding>,
        refusal: Option<SemanticTransitionRefusal>,
    ) -> Result<(), SemanticTransitionError> {
        let Some(policy) = self.policy.as_ref() else {
            return Ok(());
        };
        let invocation = invocation.ok_or(SemanticTransitionError::ObservationMismatch)?;
        let next_state = &policy
            .replacement
            .as_ref()
            .expect("proposal reserved its next working banks")
            .state;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&self.state);
        recorder.write(next_state);
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |enqueue| {
            // SAFETY: the recorded source and reserved destination each hold
            // exactly one DeviceState on the controller's ordered CUDA stream.
            unsafe {
                sys::cuMemcpyDtoDAsync_v2(
                    next_state.device_ptr_value(),
                    self.state.device_ptr_value(),
                    size_of::<DeviceState>(),
                    enqueue.stream().cu_stream(),
                )
            }
            .result()
            .map_err(|error| XlogError::Kernel(error.to_string()))
        })?;
        let mut policy = self.policy.take().expect("checked original policy");
        let replacement = policy
            .replacement
            .take()
            .expect("proposal reserved its next working banks");
        self.rng = None;
        self.captured = None;
        self.policy_tapes.push(PolicyTape {
            invocation,
            refusal,
            binding: self.binding(),
            policy,
            support: std::mem::replace(&mut self.support, replacement.support),
            receipts: std::mem::replace(&mut self.receipts, replacement.receipts),
            prepared_bank: None,
            origin_state: Some(std::mem::replace(&mut self.state, replacement.state)),
            components: self.device_components.view(),
            codebooks: self.device_codebooks.view(),
        });
        Ok(())
    }

    fn observe_terminal(
        &mut self,
        expected_proposal: u32,
    ) -> Result<SemanticTransitionOutcome, SemanticTransitionError> {
        let _ordinary = crate::cuda_graph::reserve_uncaptured_stream(&self.stream)
            .map_err(|error| runtime_error("terminal observation stream admission", error))?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "terminal wait",
            CudaStream::synchronize,
        )?;
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(&self.state);
        recorder.read(&self.receipts);
        // SAFETY: pinned destination and tracked sources live through the second
        // wait, including cleanup on an enqueue/commit error.
        enqueue_recorded(&self.domain, &mut self.poisoned, recorder, |stream| {
            self.pinned.enqueue_copy(
                self.state.device_ptr_value(),
                self.receipts.device_ptr_value(),
                stream.stream(),
            )
        })?;
        wait_on_stream(
            &self.stream,
            &mut self.poisoned,
            &mut self.stream_waits,
            "observation wait",
            CudaStream::synchronize,
        )?;
        // SAFETY: both transfers and the final stream wait succeeded.
        let (state, components) = unsafe { self.pinned.read()? };
        self.provider
            .record_final_observation_transfer(size_of::<DeviceState>() as u64);
        self.provider.record_final_observation_transfer(
            (COMPONENT_COUNT * size_of::<SemanticTransitionReceipt>()) as u64,
        );
        if matches!(state.status, 2 | 5 | 11 | 12..=14) && self.publication.is_some() {
            let refusal = self.reconcile_refusal(&state, expected_proposal)?;
            return Ok(SemanticTransitionOutcome::Refused(refusal));
        }
        if state.status == 2 {
            return Err(SemanticTransitionError::InvalidFinalSupport {
                completed_draws: state.blocks,
            });
        }
        if state.status == 5 {
            return Err(SemanticTransitionError::NonFinitePolicyInput {
                completed_draws: state.blocks,
            });
        }
        if state.status == 11 {
            return Err(SemanticTransitionError::WorkCounterOverflow {
                completed_draws: state.blocks,
            });
        }
        if matches!(state.status, 12..=14) {
            return Err(SemanticTransitionError::InvalidTrainingView {
                status: state.status - 11,
            });
        }
        match state.status {
            7 => return Err(SemanticTransitionError::InvalidTaskBank),
            8 => return Err(SemanticTransitionError::InvalidTaskBase),
            9 => return Err(SemanticTransitionError::TaskOwnerFailure),
            _ => {}
        }
        let published = if self.publication.is_some() {
            Some(self.reconcile_publication(&state, expected_proposal)?)
        } else {
            None
        };
        let rng = self
            .rng
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if expected_proposal != rng.proposal || u64::from(expected_proposal) != self.next_proposal {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let policy_text = false;
        #[cfg(feature = "semantic-policy")]
        let policy_text = self.policy.is_some() || policy_text;
        self.finish_observed_transition(state, components, rng, published, policy_text)
    }

    fn finish_observed_transition(
        &mut self,
        state: DeviceState,
        components: Vec<SemanticTransitionReceipt>,
        rng: SemanticRngBinding,
        published: Option<(
            PublicationHeader,
            (SemanticRootHandle, SemanticRootSnapshot),
            SemanticTransitionKind,
        )>,
        policy_text: bool,
    ) -> Result<SemanticTransitionOutcome, SemanticTransitionError> {
        let proposal = u64::from(rng.proposal);
        if state.model_generation != rng.model_generation
            || state.family_id != u32::from(rng.family_id)
            || state.stream_serial != rng.stream_serial
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        if let Some((header, (root, snapshot), kind)) = published {
            if kind != SemanticTransitionKind::Proposal {
                if state.status != 0
                    || state.blocks != 0
                    || state.proposal != proposal
                    || state.next_proposal != proposal
                    || state.importance_weight != 1.0
                {
                    return Err(SemanticTransitionError::ObservationMismatch);
                }
                self.root = root;
                self.base_snapshot = snapshot;
                self.next_proposal = header.proposal;
                return Ok(SemanticTransitionOutcome::Published(
                    SemanticTransitionObservation {
                        components: Vec::new(),
                        root_handle: root,
                        root: snapshot,
                        next_proposal: header.proposal,
                        lanes: std::array::from_fn(|_| SemanticTransitionLane {
                            root: None,
                            task_refusal: None,
                            program_rules: [None; 2],
                            edits: [Ok(None), Ok(None)],
                            work: SemanticTransitionWork::default(),
                        }),
                        importance_weight: state.importance_weight,
                        task_evaluation: None,
                    },
                ));
            }
        }
        if state.semantic_receipts[0][0] != 0 {
            self.graph
                .observe_transition_root(state.semantic_receipts[0])
                .map_err(SemanticTransitionError::Semantic)?;
        }
        let binding = SemanticActionCatalogue::current().binding();
        let editable_program = self
            .task
            .as_ref()
            .is_some_and(|(task, _)| task.spec().program.editable_program().is_some());
        if state.status != 0
            || state.proposal != proposal
            || state.next_proposal != proposal + 1
            || components.len() != COMPONENT_COUNT
            || state.blocks != COMPONENT_COUNT as u64
            || state.catalogue_generation != binding.generation
            || state.catalogue_digest != binding.digest
            || state.binding_digest != self.binding().digest
            || state
                .work
                .iter()
                .any(|work| !work.is_valid(editable_program))
            || (published.is_none() && state.retired_roots_mask != 0)
            || state.retired_roots_mask & !3 != 0
            || !state.importance_weight.is_finite()
            || state.importance_weight <= 0.0
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        for (row, component) in components.iter().zip(&self.codebooks.components) {
            let inactive_text = policy_text
                && component.kind == COMPONENT_KIND_TEXT as u32
                && canonical_text_null(row);
            if row.ordinal != component.ordinal
                || row.lane != component.lane
                || row.slot != component.slot
                || row.field != component.field
                || row.kind != component.kind
                || row.proposal != state.proposal
                || row.catalogue_generation != binding.generation
                || row.catalogue_digest != binding.digest
                || row.admission_binding != self.binding().digest
                || if inactive_text {
                    !canonical_text_null(row)
                } else {
                    row.choice >= component.cardinality
                }
                || row.cdf_start > row.draw
                || row.draw >= row.cdf_end
                || row.cdf_end > 1u64 << 63
                || row.cdf_end - row.cdf_start != row.mass
                || row.mass < 1u64 << 32
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
        }
        let mut integrity_error = None;
        let task_evaluation = if let Some((binding, _)) = &self.task {
            let task = &state.task_evaluation;
            if task.query_count < 3
                || task.query_count > 9
                || !task.query_count.is_multiple_of(3)
                || task.winner > 2
                || task.facts[task.winner as usize].eligible != 1
                || task.lane_refusal.iter().any(|&code| code > 4)
                || (binding.spec.program.editable_program().is_none()
                    && task.lane_refusal.iter().any(|&code| code >= 3))
            {
                return Err(SemanticTransitionError::ObservationMismatch);
            }
            Some(SemanticTaskEvaluation {
                binding: binding.identity(),
                query_count: task.query_count,
                winner: task.winner,
                return_value: task.return_value,
                facts: task.facts,
            })
        } else {
            None
        };
        let edit_choices: [[[u32; 18]; 2]; 2] = std::array::from_fn(|lane| {
            std::array::from_fn(|slot| {
                std::array::from_fn(|field| components[lane * 68 + 32 + slot * 18 + field].choice)
            })
        });
        let mut program_rules = [[None; 2]; 2];
        if let Some((task, _)) = &self.task {
            if let Some(program) = task.spec().program.editable_program() {
                if let Err(error) = validate_program_query_receipts(
                    program,
                    task.identity(),
                    &self.codebooks,
                    &state,
                    &edit_choices,
                ) {
                    self.poisoned = true;
                    return Err(error);
                }
                for lane in 0..2 {
                    for slot in 0..2 {
                        let choices = &edit_choices[lane][slot];
                        let receipt = &state.semantic_receipts[1 + lane * 3 + slot];
                        if choices[0] == 1 && choices[1] == 2 {
                            let previous = (slot == 1).then_some(&edit_choices[lane][0]);
                            match validated_rule_receipt(
                                &self.codebooks,
                                program,
                                task.identity(),
                                lane,
                                slot,
                                choices,
                                previous,
                                receipt,
                            ) {
                                Ok((decoded, _)) => program_rules[lane][slot] = Some(decoded.rule),
                                Err(error) => {
                                    self.poisoned = true;
                                    return Err(error);
                                }
                            }
                        } else if choices[0] == 1 || receipt[1] == 3 {
                            self.poisoned = true;
                            return Err(SemanticTransitionError::ObservationMismatch);
                        }
                    }
                }
            }
        }
        let lanes = std::array::from_fn(|i| {
            let task_refusal = if task_evaluation.is_some() {
                match state.task_evaluation.lane_refusal[i] {
                    1 => Some(SemanticTaskRefusal::Scope),
                    2 => Some(SemanticTaskRefusal::HardConstraint),
                    3 => Some(SemanticTaskRefusal::FactCapacity),
                    4 => Some(SemanticTaskRefusal::FuelExhausted),
                    _ => None,
                }
            } else {
                None
            };
            let root =
                (task_refusal.is_none() && state.retired_roots_mask & (1 << i) == 0).then(|| {
                    self.graph
                        .observe_transition_root(state.semantic_receipts[3 + i * 3])
                });
            if self.graph.ensure_not_poisoned().is_err() {
                if let Some(Err(error)) = &root {
                    integrity_error.get_or_insert_with(|| error.clone());
                }
            }
            let edits = std::array::from_fn(|j| {
                let result = if program_rules[i][j].is_some() {
                    Ok(None)
                } else {
                    self.graph
                        .observe_transition_edit(state.semantic_receipts[1 + i * 3 + j])
                };
                if self.graph.ensure_not_poisoned().is_err() {
                    if let Err(error) = &result {
                        integrity_error.get_or_insert_with(|| error.clone());
                    }
                }
                result
            });
            SemanticTransitionLane {
                root,
                task_refusal,
                program_rules: program_rules[i],
                edits,
                work: state.work[i],
            }
        });
        if let Some(error) = integrity_error {
            return Err(SemanticTransitionError::Semantic(error));
        }
        if let Some((_, (root, snapshot), _)) = published {
            self.root = root;
            self.base_snapshot = snapshot;
        }
        self.next_proposal = state.next_proposal;
        if let Ok(proposal) = u32::try_from(self.next_proposal) {
            self.rng = Some(SemanticRngBinding { proposal, ..rng });
        }
        Ok(SemanticTransitionOutcome::Published(
            SemanticTransitionObservation {
                components,
                root_handle: self.root,
                root: self.base_snapshot,
                next_proposal: state.next_proposal,
                lanes,
                importance_weight: state.importance_weight,
                task_evaluation,
            },
        ))
    }

    fn reconcile_refusal(
        &mut self,
        state: &DeviceState,
        expected_proposal: u32,
    ) -> Result<SemanticTransitionRefusal, SemanticTransitionError> {
        let rng = self
            .rng
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if rng.proposal != expected_proposal || u64::from(expected_proposal) != self.next_proposal {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let refusal = refused_terminal(
            state,
            rng,
            SemanticActionCatalogue::current().binding(),
            self.binding().digest,
            None,
        )?;
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let (token, base_word, _) = self
            .admitted_transition
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let original = Arc::clone(
            self.text_binding
                .as_ref()
                .ok_or(SemanticTransitionError::ObservationMismatch)?,
        );
        let reader = self
            .readers
            .get(&token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let step = self
            .steps
            .get(&token)
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        if self.continuation_base != Some(base_word)
            || original._witness.reader_token != token
            || original.published_parent()?.0 != (base_word & 1) as usize
            || !Arc::ptr_eq(&original._witness.issuer, &self.publication_issuer)
            || !Arc::ptr_eq(&original._witness._witness, &step.content_witnesses)
            || step
                .content
                .get(original._witness.index)
                .is_none_or(|content| !matches!(content.seals, TensorContentSeals::Captured(_)))
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let lease_view = reader.device.view();
        let lease = self.publication_read(lease_view)?[0];
        let control = self.publication_read(storage.control.view())?[0];
        if lease.abi != 1
            || lease.status != 0
            || lease.active != 1
            || lease.instance != storage.instance
            || lease.word != base_word
            || lease.bank != base_word & 1
            || lease.epoch != base_word >> 1
            || control.reader_counts[lease.bank as usize] == 0
            || control.abi != 1
            || control.instance != storage.instance
            || control.word != base_word
            || control.reader_gate != 0
            || control.refusal != 0
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let (bank, parent_header) = original.published_parent()?;
        let header = self.read_publication_header(bank)?;
        if header != parent_header
            || header.abi != 1
            || header.instance != storage.instance
            || header.publication_word != base_word
            || header.sealed_epoch != base_word >> 1
            || header.proposal != state.proposal
            || header.model_generation != u64::from(state.model_generation)
            || header.family_id != u64::from(state.family_id)
            || header.stream_serial != state.stream_serial
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        // The kernel snapshots this exact protected root after ordinary cleanup,
        // including the pre-staging numerical refusal. No success receipt is invented.
        let (root, snapshot) = self.observe_publication_root(state, &header, 0)?;
        if root != self.root || snapshot != self.base_snapshot {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        refused_root_cleanup(
            state,
            self.graph.transition_arena()[1],
            u64::from(root.slot()),
            root.generation(),
        )?;
        Ok(refusal)
    }

    fn observe_publication_root(
        &mut self,
        state: &DeviceState,
        header: &PublicationHeader,
        index: usize,
    ) -> Result<(SemanticRootHandle, SemanticRootSnapshot), SemanticTransitionError> {
        let (root, snapshot) = self
            .graph
            .observe_transition_root(state.semantic_receipts[index])
            .map_err(SemanticTransitionError::Semantic)?;
        let extents = snapshot.extents();
        if header.semantic_owner != self.graph.transition_arena()[1]
            || header.semantic_slot != u64::from(root.slot())
            || header.semantic_generation != root.generation()
            || header.semantic_digest.as_bytes() != snapshot.digest().as_bytes()
            || header.semantic_extents
                != [
                    u64::from(extents.statements()),
                    u64::from(extents.supports()),
                    u64::from(extents.versions()),
                ]
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        Ok((root, snapshot))
    }

    fn reconcile_publication(
        &mut self,
        state: &DeviceState,
        expected_proposal: u32,
    ) -> Result<
        (
            PublicationHeader,
            (SemanticRootHandle, SemanticRootSnapshot),
            SemanticTransitionKind,
        ),
        SemanticTransitionError,
    > {
        let storage = Arc::clone(
            self.publication
                .as_ref()
                .ok_or(SemanticTransitionError::NotBound)?,
        );
        let (_, base_word, kind) = self
            .admitted_transition
            .ok_or(SemanticTransitionError::ObservationMismatch)?;
        let control = self.publication_read(storage.control.view())?[0];
        if control.refusal != 0 || state.status == 10 {
            return Err(SemanticTransitionError::PublicationRefused {
                status: control.refusal,
            });
        }
        let epoch = (base_word >> 1)
            .checked_add(1)
            .filter(|&epoch| epoch <= u64::MAX >> 1)
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        let expected_word = (epoch << 1) | ((base_word ^ 1) & 1);
        if state.status != 0
            || control.abi != 1
            || control.instance != storage.instance
            || control.word != expected_word
            || self.continuation_base != Some(base_word)
            || u64::from(expected_proposal) != self.next_proposal
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let header = self.read_publication_header((expected_word & 1) as usize)?;
        let next_proposal = self
            .next_proposal
            .checked_add(u64::from(kind == SemanticTransitionKind::Proposal))
            .ok_or(SemanticTransitionError::GenerationExhausted)?;
        if header.abi != 1
            || header.instance != control.instance
            || header.base_word != base_word
            || header.publication_word != expected_word
            || header.sealed_epoch != epoch
            || header.proposal != next_proposal
        {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let winner = if kind == SemanticTransitionKind::Proposal {
            state.task_evaluation.winner
        } else {
            0
        };
        let index = match winner {
            0 => 0,
            1 => 3,
            2 => 6,
            _ => return Err(SemanticTransitionError::ObservationMismatch),
        };
        if winner > 0 && state.retired_roots_mask & (1 << (winner - 1)) != 0 {
            return Err(SemanticTransitionError::ObservationMismatch);
        }
        let root = self.observe_publication_root(state, &header, index)?;
        Ok((header, root, kind))
    }

    fn ensure_quiescent(&self) -> Result<(), SemanticTransitionError> {
        if self.is_poisoned() {
            Err(SemanticTransitionError::Poisoned)
        } else if self.pending {
            Err(SemanticTransitionError::OverlappingLaunch)
        } else {
            Ok(())
        }
    }

    fn ensure_rebindable(&self) -> Result<(), SemanticTransitionError> {
        if self.initial_prefill.is_some() {
            return Err(publication_input_error(
                "an imported task's initial prefill stage cannot be rebound",
            ));
        }
        self.ensure_rebindable_with_prefill()
    }

    fn ensure_rebindable_with_prefill(&self) -> Result<(), SemanticTransitionError> {
        self.ensure_quiescent()?;
        #[cfg(feature = "semantic-policy")]
        self.require_closed_evaluations()?;
        validate_rebinding_ownership(
            self.prepared_segment.as_ref(),
            self.steps.values().any(|step| step.identity.is_none()),
        )?;
        if self.task_observed {
            return Err(SemanticTransitionError::UnpublishedTask);
        }
        #[cfg(feature = "semantic-policy")]
        if self.policy.as_ref().is_some_and(|policy| policy.tape_live) {
            return Err(SemanticTransitionError::UnconsumedPolicyTape);
        }
        Ok(())
    }

    fn transition_kernel_io(&self) -> TransitionKernelIo<'_> {
        let logits = &self.logits;
        let text = self.text_binding.as_deref();
        #[cfg(feature = "semantic-policy")]
        let (logits, text) = self.policy.as_ref().map_or((logits, text), |policy| {
            (&policy.text_logits, Some(policy.text_binding.as_ref()))
        });
        TransitionKernelIo {
            logits,
            support: &self.support,
            receipts: &self.receipts,
            state: &self.state,
            text,
            model_work: None,
            replay_custody: None,
            model_update: None,
            lease: self
                .admitted_transition
                .map(|(token, _, _)| &self.readers[&token].device),
            #[cfg(feature = "semantic-policy")]
            policy: self.policy.as_ref(),
            training_selection: None,
        }
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_kernel_io(
        &self,
        step: &SemanticPreparedStep,
        bank: usize,
    ) -> Result<TransitionKernelIo<'_>, SemanticTransitionError> {
        let prepared = self
            .steps
            .get(&step.token)
            .and_then(|owner| owner.prepared.as_ref())
            .ok_or_else(|| {
                publication_input_error("prepared transition has no original storage")
            })?;
        let branch = prepared
            .branches
            .get(bank)
            .ok_or_else(|| publication_input_error("prepared transition bank is invalid"))?;
        let policy = branch.policy.as_ref();
        let text = &branch
            .continuation
            .as_ref()
            .ok_or_else(|| {
                publication_input_error("prepared transition has no original continuation")
            })?
            .text_binding;
        let logits = match policy {
            Some(policy) => &policy.text_logits,
            None => {
                &branch
                    .policy_buffers
                    .as_ref()
                    .ok_or_else(|| {
                        publication_input_error("prepared transition has no retained cold buffers")
                    })?
                    .text_logits
            }
        };
        Ok(TransitionKernelIo {
            // Nonproposal execution returns before reading logits or support.
            // Retain the original cold allocation; do not invent policy values.
            logits,
            support: branch
                .support
                .as_ref()
                .ok_or_else(|| publication_input_error("prepared support has retired"))?,
            receipts: branch
                .receipts
                .as_ref()
                .ok_or_else(|| publication_input_error("prepared receipts have retired"))?,
            state: &branch.state,
            text: Some(text),
            lease: Some(&prepared.reader),
            policy,
            model_work: prepared.model_work.as_ref(),
            replay_custody: prepared.replay_custody.as_ref(),
            model_update: branch.model_update.as_ref(),
            training_selection: branch
                .continuation
                .as_ref()
                .and_then(|continuation| continuation.training_selection.as_ref()),
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn prepared_drain_kernel_io(
        &self,
        step: &SemanticPreparedStep,
    ) -> Result<TransitionKernelIo<'_>, SemanticTransitionError> {
        let prepared = self
            .steps
            .get(&step.token)
            .and_then(|owner| owner.prepared.as_ref())
            .ok_or_else(|| publication_input_error("prepared drain has no original storage"))?;
        let branch = &prepared.branches[0];
        let logits = if let Some(policy) = branch.policy.as_ref() {
            &policy.text_logits
        } else {
            &branch
                .policy_buffers
                .as_ref()
                .ok_or_else(|| {
                    publication_input_error("prepared drain has no retained cold buffers")
                })?
                .text_logits
        };
        Ok(TransitionKernelIo {
            logits,
            support: branch
                .support
                .as_ref()
                .ok_or_else(|| publication_input_error("prepared support has retired"))?,
            receipts: branch
                .receipts
                .as_ref()
                .ok_or_else(|| publication_input_error("prepared receipts have retired"))?,
            state: &branch.state,
            text: None,
            lease: Some(&prepared.reader),
            policy: None,
            model_work: None,
            model_update: None,
            training_selection: None,
            replay_custody: None,
        })
    }

    fn descriptor(&self) -> Descriptor {
        self.descriptor_with(&self.transition_kernel_io())
    }

    fn descriptor_with(&self, io: &TransitionKernelIo<'_>) -> Descriptor {
        #[cfg(not(feature = "semantic-policy"))]
        let policy = PolicyDescriptor::default();
        #[cfg(feature = "semantic-policy")]
        let policy = io.policy.map_or(PolicyDescriptor::default(), |policy| {
            Self::retained_policy_descriptor(&policy.buffers)
        });
        Descriptor {
            logits: 0,
            support: 0,
            scratch: self.scratch.device_ptr_value(),
            receipts: 0,
            state: 0,
            components: self.device_components.device_ptr_value(),
            codebooks: self.device_codebooks.device_ptr_value(),
            arena: self.graph.transition_arena(),
            policy: PolicyDescriptor::default(),
            backward: PolicyBackward::default(),
            task: self
                .task
                .as_ref()
                .map_or(0, |(_, device)| device.device_ptr_value()),
            task_words: self
                .task
                .as_ref()
                .map_or(0, |(_, device)| device.len() as u64),
            task_return_bound: self
                .task
                .as_ref()
                .map_or(0, |(binding, _)| binding.objective_law.return_bound as u64),
            publication: PublicationCommand {
                control: self
                    .publication
                    .as_ref()
                    .map_or(0, |storage| storage.control.device_ptr_value()),
                lease: 0,
                operation: 0,
            },
            text: TextBinding::default(),
            model_work: ModelWorkInput::default(),
            replay: io.replay_custody.map_or(
                PreparedReplayDescriptor::default(),
                PreparedReplayCustody::descriptor,
            ),
        }
        .with_transition(TransitionKernelPointers {
            logits: io.logits.device_ptr_value(),
            support: io.support.device_ptr_value(),
            receipts: io.receipts.device_ptr_value(),
            state: io.state.device_ptr_value(),
            lease: io.lease.map_or(0, TrackedCudaSlice::device_ptr_value),
            text: io
                .text
                .map_or(TextBinding::default(), TextBindingStorage::descriptor),
            policy,
            model_work: io
                .model_work
                .map_or(ModelWorkInput::default(), PreparedModelWork::descriptor),
        })
    }

    #[cfg(feature = "semantic-policy")]
    fn retained_policy_descriptor(policy: &PolicyBuffers) -> PolicyDescriptor {
        let parameter = |offset: usize| policy.parameters.device_ptr_value() + (offset * 4) as u64;
        let mut retained_offset = 0usize;
        let fields = std::array::from_fn(|i| {
            let field = &policy.layout.fields[i];
            let result = PolicyField {
                embeddings: if field.embeddings.is_empty() {
                    0
                } else {
                    parameter(field.embeddings.start)
                },
                biases: if field.biases.is_empty() {
                    0
                } else {
                    parameter(field.biases.start)
                },
                cardinality: field.cardinality as u32,
                null_category: field.null_category.map_or(-1, |index| index as i32),
                retained_offset: retained_offset as u64,
            };
            retained_offset += field.cardinality;
            result
        });
        PolicyDescriptor {
            z: parameter(policy.layout.z.start),
            recurrence: parameter(policy.layout.recurrence.start),
            positions: parameter(policy.layout.positions.start),
            hidden: policy.hidden.device_ptr_value(),
            scores: policy.scores.device_ptr_value(),
            recurrent: policy.recurrent.device_ptr_value(),
            retained_scores: policy.retained_scores.device_ptr_value(),
            retained_score_stride: policy.layout.retained_score_stride() as u64,
            final_masks: policy.final_masks.device_ptr_value(),
            active_sets: policy.active_sets.device_ptr_value(),
            pwl_cells: policy.pwl_cells.device_ptr_value(),
            selected_score_vjps: policy.selected_score_vjps.device_ptr_value(),
            component_baselines: policy.component_baselines.device_ptr_value(),
            fields,
            numerical: policy.numerical.descriptor(policy.layout.parameter_cells),
        }
    }

    fn validate_ranges(&self) -> Result<(), SemanticTransitionError> {
        self.validate_ranges_with(&self.transition_kernel_io())
    }

    fn validate_ranges_with(
        &self,
        io: &TransitionKernelIo<'_>,
    ) -> Result<(), SemanticTransitionError> {
        let d = self.descriptor_with(io);
        let mut ranges = vec![
            (d.logits, (io.logits.len() * 4) as u64),
            (d.support, io.support.len() as u64),
            (d.scratch, SCRATCH_BYTES as u64),
            (
                d.receipts,
                (io.receipts.len() * size_of::<SemanticTransitionReceipt>()) as u64,
            ),
            (d.state, size_of::<DeviceState>() as u64),
            (
                d.components,
                (COMPONENT_COUNT * size_of::<SemanticComponent>()) as u64,
            ),
            (d.codebooks, (self.codebooks.words.len() * 8) as u64),
            (d.arena[0], d.arena[6] * 8),
        ];
        if let Some((_, device)) = &self.task {
            ranges.push((device.device_ptr_value(), (device.len() * 8) as u64));
        }
        #[cfg(feature = "semantic-policy")]
        {
            if let Some(policy) = io.policy {
                for buffer in policy.numerical.buffers() {
                    ranges.push((buffer.device_ptr_value(), (buffer.len() * 8) as u64));
                }
                for buffer in [
                    &policy.parameters,
                    &policy.hidden,
                    &policy.scores,
                    &policy.retained_scores,
                    &policy.recurrent,
                    &policy.component_baselines,
                ] {
                    if !buffer.is_empty() {
                        ranges.push((buffer.device_ptr_value(), (buffer.len() * 4) as u64));
                    }
                }
                for buffer in [&policy.final_masks, &policy.active_sets] {
                    if !buffer.is_empty() {
                        ranges.push((buffer.device_ptr_value(), buffer.len() as u64));
                    }
                }
                ranges.push((
                    policy.pwl_cells.device_ptr_value(),
                    (policy.pwl_cells.len() * size_of::<SemanticPolicyPwlCell>()) as u64,
                ));
                ranges.push((
                    policy.selected_score_vjps.device_ptr_value(),
                    (policy.selected_score_vjps.len() * size_of::<SemanticPolicySelectedScoreVjp>())
                        as u64,
                ));
            }
        }
        if let Some(text) = io.text {
            for input in &text.inputs {
                if let Some(source) = &input.source {
                    ranges.push((input.data, source.len() as u64));
                }
            }
        }
        if let Some(selection) = io.training_selection {
            ranges.push((
                *selection.device_ptr(),
                size_of::<SemanticTrainingViewSelection>() as u64,
            ));
        }
        if let Some(update) = io.model_update {
            ranges.push((
                update.bindings.device_ptr_value(),
                (update.bindings.len() * size_of::<ModelUpdateBinding>()) as u64,
            ));
            if let Some(output) = &update.output {
                for allocation in &output.allocations {
                    if let Some(source) = &allocation.source {
                        ranges.push((allocation.data, source.len() as u64));
                    }
                }
                if let Some(source) = &output.admissibility.source {
                    ranges.push((output.admissibility.data, source.len() as u64));
                }
                if let Some(source) = &output.baseline_logits.source {
                    ranges.push((output.baseline_logits.data, source.len() as u64));
                }
                if let Some(source) = &output.candidate_logits.source {
                    ranges.push((output.candidate_logits.data, source.len() as u64));
                }
            }
        }
        disjoint_ranges(&ranges)
    }

    fn kernel_recorder(&self) -> LaunchRecorder {
        self.kernel_recorder_with(&self.transition_kernel_io())
    }

    fn kernel_recorder_with(&self, io: &TransitionKernelIo<'_>) -> LaunchRecorder {
        // Replay custody is never exposed as a numerical alias. Retain all
        // original private destinations for the complete captured transaction.
        let mut recorder = self.domain.new_strict_recorder();
        recorder.read(io.logits);
        recorder.read(io.support);
        if let Some(work) = io.model_work {
            recorder.read(&work.device);
            recorder.read(&work.actual);
        }
        if let Some(custody) = io.replay_custody {
            custody.record(&mut recorder);
        }
        if let Some(update) = io.model_update {
            update.record(&mut recorder);
        }
        recorder.write(&self.scratch);
        recorder.write(io.receipts);
        recorder.read_write(io.state);
        recorder.read(&self.device_codebooks);
        recorder.read(&self.device_components);
        if let Some((_, device)) = &self.task {
            recorder.read(device);
        }
        #[cfg(feature = "semantic-policy")]
        if let Some(policy) = io.policy {
            policy.numerical.record(&mut recorder);
            recorder.read(&policy.parameters);
            recorder.read(&policy.component_baselines);
            recorder.write(&policy.hidden);
            recorder.write(&policy.scores);
            recorder.write(&policy.retained_scores);
            recorder.write(&policy.final_masks);
            recorder.write(&policy.active_sets);
            recorder.write(&policy.pwl_cells);
            recorder.write(&policy.selected_score_vjps);
            recorder.write(&policy.recurrent);
        }
        self.graph.record_transition(&mut recorder);
        if let Some(publication) = &self.publication {
            publication.record(&mut recorder);
        }
        if let Some(lease) = io.lease {
            recorder.read(lease);
        }
        if let Some(text) = io.text {
            text.record(&mut recorder);
        }
        if let Some(selection) = io.training_selection {
            recorder.read(selection);
        }
        recorder
    }
}

fn enqueue_recorded<E: fmt::Display>(
    domain: &ResidentExecutionDomain,
    poisoned: &mut bool,
    recorder: LaunchRecorder,
    operation: impl FnOnce(&CudaEnqueue<'_>) -> Result<(), E>,
) -> Result<(), SemanticTransitionError> {
    // SAFETY: all call sites register exactly the allocations used on the supplied
    // stream. Poison is armed before the may-enqueue boundary, including unwinding;
    // only a successful consuming commit permits reuse.
    let result = unsafe {
        domain.enqueue(recorder, |stream| {
            *poisoned = true;
            operation(stream)
        })
    };
    let enqueued = result.map_err(|e| {
        if matches!(
            &e,
            LaunchEnqueueError::Operation(_) | LaunchEnqueueError::OperationAndCleanup { .. }
        ) {
            *poisoned = true;
        }
        runtime_error("enqueue", e)
    })?;
    enqueued
        .commit()
        .map_err(|e| runtime_error("enqueue commit", e))?;
    *poisoned = false;
    Ok(())
}

fn wait_on_stream<E: fmt::Display>(
    stream: &CudaStream,
    poisoned: &mut bool,
    waits: &mut u64,
    operation: &'static str,
    wait: impl FnOnce(&CudaStream) -> Result<(), E>,
) -> Result<(), SemanticTransitionError> {
    *waits += 1;
    wait(stream).map_err(|e| {
        *poisoned = true;
        runtime_error(operation, e)
    })
}

fn validate_bound_inputs(
    components: &[SemanticComponent],
    rng: SemanticRngBinding,
    inputs: &[SemanticComponentInput],
) -> Result<(), SemanticTransitionError> {
    let invalid = |detail: &str| SemanticTransitionError::InvalidInput {
        detail: detail.into(),
    };
    if rng.stream_serial >= 1u64 << 56 {
        return Err(invalid("stream serial exceeds 56 bits"));
    }
    if inputs.len() != COMPONENT_COUNT {
        return Err(invalid("input roster must contain exactly 136 components"));
    }
    for (component, input) in components.iter().zip(inputs) {
        if input.logits.len() != component.cardinality as usize
            || input.product_support.len() != input.logits.len()
        {
            return Err(invalid("logits/support shape differs from the catalogue"));
        }
        if input.product_support.iter().any(|&m| m > 1) {
            return Err(invalid("product support must be binary"));
        }
        debug_assert!(component.is_text() || component.kind == COMPONENT_KIND_EDIT as u32);
        let has_support = input.product_support.contains(&1);
        if !has_support {
            return Err(invalid("empty product support"));
        }
        if input
            .logits
            .iter()
            .zip(&input.product_support)
            .any(|(&z, &m)| m == 1 && !z.is_finite())
        {
            return Err(invalid("legal logits must be finite FP32"));
        }
    }
    Ok(())
}

fn disjoint_ranges(ranges: &[(u64, u64)]) -> Result<(), SemanticTransitionError> {
    for (i, &(start, len)) in ranges.iter().enumerate() {
        let end = start
            .checked_add(len)
            .filter(|_| start != 0 && len != 0)
            .ok_or(SemanticTransitionError::OverlappingInputs)?;
        for &(other, other_len) in &ranges[..i] {
            let other_end = other
                .checked_add(other_len)
                .ok_or(SemanticTransitionError::OverlappingInputs)?;
            if start < other_end && other < end {
                return Err(SemanticTransitionError::OverlappingInputs);
            }
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    #[test]
    fn raw_prefix_export_retains_the_original_input_seal() {
        let range = PublicationRange {
            role: 1,
            index: 0,
            generation: 1,
            length_bytes: 64,
            logical_begin: 0,
            logical_end: 1,
            ..PublicationRange::default()
        };
        let input = StepInputPlan {
            role: 1,
            index: 0,
            layout: committed_prefix_layout(&range, 4).unwrap(),
            banks: [
                StepInputBankPlan {
                    storage_slot: 0,
                    span: 0..256,
                },
                StepInputBankPlan {
                    storage_slot: 0,
                    span: 0..256,
                },
            ],
        };
        let raw = publication_record_layout(&range);
        let exported = publication_export_span(&range, &raw, 256).unwrap();
        assert_eq!(exported, 0..64);
        assert!(step_input_alias_matches(
            &input,
            &range,
            4096,
            256,
            (raw, 0, 0, 4096, exported.len())
        ));
        assert!(!step_input_alias_matches(
            &input,
            &range,
            4096,
            256,
            (raw, 0, 0, 4097, exported.len())
        ));
        assert!(!step_input_alias_matches(
            &input,
            &range,
            4096,
            256,
            (raw, 0, 1, 4096, exported.len())
        ));
        assert!(!step_input_alias_matches(
            &input,
            &range,
            4096,
            256,
            (raw, 0, 0, 4096, 128)
        ));
        assert!(step_input_alias_matches(
            &input,
            &range,
            4096,
            256,
            (input.layout, 0, 1, 4096, 256)
        ));
        let empty = PublicationRange {
            length_bytes: 0,
            logical_end: 0,
            ..range
        };
        let raw_empty = publication_record_layout(&empty);
        assert_eq!(
            publication_export_span(&empty, &raw_empty, 256).unwrap(),
            0..0
        );
        assert!(step_input_alias_matches(
            &input,
            &empty,
            4096,
            256,
            (raw_empty, 0, 0, 4096, 0)
        ));
    }

    #[test]
    fn transition_descriptors_preserve_each_original_policy_and_outcome() {
        use super::*;
        let shared = Descriptor {
            logits: 0,
            support: 0,
            scratch: 8,
            receipts: 0,
            state: 0,
            components: 16,
            codebooks: 24,
            arena: [32; 7],
            policy: PolicyDescriptor::default(),
            backward: PolicyBackward::default(),
            task: 40,
            task_words: 66,
            task_return_bound: 0,
            publication: PublicationCommand {
                control: 48,
                lease: 0,
                operation: 0,
            },
            text: TextBinding::default(),
            model_work: ModelWorkInput::default(),
            replay: PreparedReplayDescriptor::default(),
        };
        let original = |base| TransitionKernelPointers {
            logits: base,
            support: base + 8,
            receipts: base + 16,
            state: base + 24,
            lease: base + 32,
            text: TextBinding {
                rows: base + 40,
                count: base + 48,
                selected: base + 56,
            },
            policy: PolicyDescriptor {
                z: base + 64,
                recurrent: base + 72,
                ..PolicyDescriptor::default()
            },
            model_work: ModelWorkInput {
                events: base + 80,
                count: base + 88,
                bound: base + 96,
            },
        };
        let first = shared.with_transition(original(1024));
        let second = shared.with_transition(original(2048));
        for (descriptor, base) in [(first, 1024), (second, 2048)] {
            assert_eq!(
                (
                    descriptor.logits,
                    descriptor.support,
                    descriptor.receipts,
                    descriptor.state
                ),
                (base, base + 8, base + 16, base + 24)
            );
            assert_eq!(
                (
                    descriptor.policy.z,
                    descriptor.policy.recurrent,
                    descriptor.publication.lease
                ),
                (base + 64, base + 72, base + 32)
            );
            assert_eq!(
                (
                    descriptor.text.rows,
                    descriptor.text.count,
                    descriptor.text.selected
                ),
                (base + 40, base + 48, base + 56)
            );
            assert_eq!(
                (
                    descriptor.model_work.events,
                    descriptor.model_work.count,
                    descriptor.model_work.bound
                ),
                (base + 80, base + 88, base + 96)
            );
            assert_eq!(
                (
                    descriptor.scratch,
                    descriptor.components,
                    descriptor.codebooks,
                    descriptor.task
                ),
                (8, 16, 24, 40)
            );
            assert_eq!(descriptor.publication.control, 48);
        }
        assert_ne!(first.policy.recurrent, second.policy.recurrent);
        assert_ne!(first.receipts, second.receipts);
    }

    const COLD_CAPACITY: SemanticSegmentColdCapacity = SemanticSegmentColdCapacity {
        tensor_content_capacity: 1,
        model_work_capacity: 1,
        segment_capacity_bytes: 1,
        other_external_cuda_bytes: 0,
    };

    #[test]
    fn prepared_schedule_preserves_each_requested_mode_until_recording() {
        let issuer = Arc::new(());
        let schedule = [
            SemanticTransitionKind::Proposal,
            SemanticTransitionKind::Recompute,
            SemanticTransitionKind::Proposal,
        ];
        let mut build = PreparedSegmentState::new(
            Arc::clone(&issuer),
            vec![4, 5, 6],
            schedule.into_iter(),
            COLD_CAPACITY,
        )
        .unwrap();
        let steps = build.handles().unwrap();
        assert!(build.enter(&steps[1], &issuer).is_err());
        for (step, expected) in steps.iter().zip(schedule) {
            assert_eq!(build.requested_kind(step, &issuer).unwrap(), expected);
            assert_eq!(build.enter(step, &issuer).unwrap(), expected);
            build.leave(step, &issuer).unwrap();
        }
        build.finish().unwrap();
        build.submit().unwrap();
        assert!(build.submit().is_err());
        assert!(build.requested_kind(&steps[0], &Arc::new(())).is_err());
        assert!(PreparedSegmentState::new(
            Arc::clone(&issuer),
            vec![9],
            schedule.into_iter(),
            COLD_CAPACITY
        )
        .is_err());
        assert!(PreparedSegmentState::new(
            issuer,
            vec![9],
            std::iter::once(SemanticTransitionKind::Drain),
            COLD_CAPACITY,
        )
        .is_err());
    }

    #[test]
    fn prepared_step_scope_rejects_foreign_owners_and_out_of_order_recording() {
        let issuer = Arc::new(());
        let mut build = PreparedSegmentState::new(
            Arc::clone(&issuer),
            vec![4, 5],
            [
                SemanticTransitionKind::Proposal,
                SemanticTransitionKind::Proposal,
            ]
            .into_iter(),
            COLD_CAPACITY,
        )
        .unwrap();
        let steps = build.handles().unwrap();
        assert!(build.check(&steps[0], &issuer, false).is_ok());
        assert!(build.check(&steps[0], &Arc::new(()), false).is_err());
        assert!(build.enter(&steps[1], &issuer).is_err());
        build.enter(&steps[0], &issuer).unwrap();
        assert!(build.check(&steps[0], &issuer, true).is_ok());
        assert!(build.check(&steps[1], &issuer, true).is_err());
        assert!(build.finish().is_err());
        build.leave(&steps[0], &issuer).unwrap();
        assert!(build.enter(&steps[0], &issuer).is_err());
        build.enter(&steps[1], &issuer).unwrap();
        build.leave(&steps[1], &issuer).unwrap();
        build.finish().unwrap();
        assert!(build.check(&steps[0], &issuer, false).is_err());
        assert!(
            PreparedSegmentState::new(issuer, Vec::new(), std::iter::empty(), COLD_CAPACITY)
                .is_err()
        );
    }
    use super::*;
    use xlog_core::MemoryBudget;

    #[test]
    fn publication_role_roster_preserves_every_required_owner() {
        let mut counts = [1; 55];
        counts[15] = 3;
        assert!(validate_publication_counts(&counts).is_ok());
        for code in [1usize, 14, 17, 38, 47, 55] {
            let mut omitted = counts;
            omitted[code - 1] = 0;
            assert!(validate_publication_counts(&omitted).is_err());
        }
        counts[18] = 0;
        counts[19] = 0;
        counts[20] = 0;
        counts[23] = 0;
        counts[24] = 0;
        assert!(validate_publication_counts(&counts).is_ok());
        counts[50] = 2;
        assert!(validate_publication_counts(&counts).is_err());
        assert!(SemanticStateRole::from_code(0).is_none());
        assert!(SemanticStateRole::from_code(56).is_none());
        assert!(SemanticStateRole::from_code(u64::MAX).is_none());
        for code in 1..=55 {
            assert_eq!(SemanticStateRole::from_code(code).unwrap() as u64, code);
        }
    }

    #[test]
    fn prefix_snapshot_copy_respects_owned_capacity_strides() {
        let source = SemanticTensorLayout {
            role: 4,
            index: 0,
            element_bytes: 2,
            scalar_type: 4,
            rank: 4,
            logical_axis: 2,
            dimensions: [1, 2, 3, 4],
            strides_bytes: [48, 24, 8, 2],
        };
        let destination = prefix_capacity_layout(source, 8).unwrap();
        assert_eq!(destination.dimensions, [1, 2, 8, 4]);
        assert_eq!(destination.strides_bytes, [128, 64, 8, 2]);
        assert_eq!(
            tensor_copy_plan(&source, &destination).unwrap(),
            [(0, 0, 24), (24, 64, 24)]
        );
        let mut empty = source;
        empty.dimensions[2] = 0;
        assert!(tensor_copy_plan(&empty, &destination).unwrap().is_empty());
    }

    #[cfg(feature = "semantic-policy")]
    #[test]
    fn policy_score_cotangent_admission_requires_exact_fp64_metadata() {
        use crate::dlpack::{DLDataType, DLDevice, DLTensor, K_DLCUDA, K_DLFLOAT, K_DLINT};

        let mut shape = [COMPONENT_COUNT as i64];
        let mut stride = [1i64];
        // This exercises the production metadata boundary only: the address is
        // never dereferenced and no CUDA provider or managed owner is created.
        let mut tensor = DLTensor {
            data: 4096usize as *mut std::ffi::c_void,
            device: DLDevice {
                device_type: K_DLCUDA,
                device_id: 0,
            },
            ndim: 1,
            dtype: DLDataType {
                code: K_DLFLOAT,
                bits: 64,
                lanes: 1,
            },
            shape: shape.as_mut_ptr(),
            strides: std::ptr::null_mut(),
            byte_offset: 0,
        };
        // SAFETY: the local shape/stride arrays outlive each metadata-only call.
        let admit = |tensor: &DLTensor| unsafe { policy_score_cotangent_metadata(tensor, 0) };
        assert_eq!(
            admit(&tensor).unwrap(),
            (4096, COMPONENT_COUNT * size_of::<f64>())
        );
        tensor.strides = stride.as_mut_ptr();
        tensor.byte_offset = 8;
        assert_eq!(
            admit(&tensor).unwrap(),
            (4104, COMPONENT_COUNT * size_of::<f64>())
        );
        tensor.byte_offset = 0;
        tensor.dtype.code = K_DLINT;
        assert!(
            admit(&tensor).is_err(),
            "Int64 cells must not be bitcast as FP64 cotangents"
        );
        tensor.dtype.code = K_DLFLOAT;
        tensor.dtype.bits = 32;
        assert!(admit(&tensor).is_err());
        tensor.dtype.bits = 64;
        tensor.dtype.lanes = 2;
        assert!(admit(&tensor).is_err());
        tensor.dtype.lanes = 1;
        for extent in [0, COMPONENT_COUNT as i64 - 1, COMPONENT_COUNT as i64 + 1] {
            shape[0] = extent;
            assert!(admit(&tensor).is_err());
        }
        shape[0] = COMPONENT_COUNT as i64;
        tensor.shape = shape.as_mut_ptr();
        stride[0] = 2;
        assert!(matches!(
            admit(&tensor),
            Err(SemanticTransitionError::InvalidInput { .. })
        ));
        stride[0] = 1;
        tensor.strides = stride.as_mut_ptr();
        tensor.ndim = 2;
        assert!(admit(&tensor).is_err());
        tensor.ndim = 1;
        tensor.device.device_id = 1;
        assert!(admit(&tensor).is_err());
        tensor.device.device_id = 0;
        tensor.byte_offset = 4;
        assert!(admit(&tensor).is_err());
    }

    #[cfg(feature = "semantic-policy")]
    #[test]
    #[ignore = "requires an explicitly authorized CUDA runtime"]
    fn policy_dlpack_binding_snapshots_actual_producer_allocations() {
        policy_dlpack_binding_fixture(PolicyFixtureCompletion::Backward);
    }

    #[cfg(feature = "semantic-policy")]
    #[test]
    #[ignore = "requires an explicitly authorized CUDA runtime"]
    fn policy_inference_finish_retires_published_and_refused_original_owners() {
        for completion in [
            PolicyFixtureCompletion::Inference,
            PolicyFixtureCompletion::NumericalRefusal,
        ] {
            policy_dlpack_binding_fixture(completion);
        }
    }

    #[cfg(feature = "semantic-policy")]
    #[derive(Clone, Copy)]
    enum PolicyFixtureCompletion {
        Backward,
        Inference,
        NumericalRefusal,
    }

    #[cfg(feature = "semantic-policy")]
    fn policy_dlpack_binding_fixture(completion: PolicyFixtureCompletion) {
        use crate::memory::CudaColumn;
        use xlog_core::{ScalarType, Schema};

        // The complete catalogue's actor/full numerical buffers exceed 3 GiB.
        let provider = Arc::new(
            crate::CudaProviderBuilder::new(0, MemoryBudget::with_limit(4 * 1024 * 1024 * 1024))
                .with_stream_capacity(1)
                .build()
                .unwrap(),
        );
        let runtime = Arc::clone(provider.memory().runtime().unwrap());
        let id = runtime.stream_pool().acquire().unwrap();
        let stream = runtime.stream_pool().resolve(id).unwrap();
        let domain = provider
            .bind_resident_execution_domain(runtime, id, stream)
            .unwrap();
        let mut session =
            super::text_parent_tests::publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(super::text_parent_tests::publication_test_parent(&provider))
            .unwrap();
        let mut parent = session.acquire().unwrap();
        session
            .admit_transition(&parent, SemanticTransitionKind::Proposal)
            .unwrap();
        let (continuation, witness) =
            super::text_parent_tests::publication_test_continuation_with_numerical_admissibility(
                &mut session,
                &parent,
                &provider,
                u8::from(!matches!(
                    completion,
                    PolicyFixtureCompletion::NumericalRefusal
                )),
            );
        session
            .bind_continuation(&parent, continuation, &witness, 1)
            .unwrap();
        let witness = if matches!(completion, PolicyFixtureCompletion::Backward) {
            drop(witness);
            None
        } else {
            Some(witness)
        };
        let layout = session.policy_layout().unwrap();
        let mut logits = provider
            .memory()
            .alloc::<f32>(32 * TEXT_CARDINALITY)
            .unwrap();
        let mut support = provider
            .memory()
            .alloc::<u8>(session.codebooks.input_cells)
            .unwrap();
        let mut parameters = provider
            .memory()
            .alloc::<f32>(layout.parameter_cells)
            .unwrap();
        let mut component_baselines = provider.memory().alloc::<f32>(COMPONENT_COUNT).unwrap();
        provider
            .htod_sync_copy_into_tracked(&vec![2.0; logits.len()], &mut logits)
            .unwrap();
        provider
            .htod_sync_copy_into_tracked(&vec![1u8; support.len()], &mut support)
            .unwrap();
        provider
            .htod_sync_copy_into_tracked(&vec![3.0; parameters.len()], &mut parameters)
            .unwrap();
        provider
            .htod_sync_copy_into_tracked(
                &vec![0.5; component_baselines.len()],
                &mut component_baselines,
            )
            .unwrap();
        let original_logit = logits.view().slice(0..1);
        let original_support = support.view().slice(0..1);
        let original_parameter = parameters.view().slice(0..1);
        let layouts = policy_numerical_producer_layouts(
            session.codebooks.input_cells,
            layout.parameter_cells,
        )
        .unwrap();
        let mut sources = vec![
            logits.into_bytes().view(),
            support.view(),
            parameters.into_bytes().view(),
            component_baselines.into_bytes().view(),
        ];
        for (index, numerical_layout) in layouts.iter().enumerate().skip(4) {
            let cells = numerical_layout.dimensions[..numerical_layout.rank as usize]
                .iter()
                .product::<u64>() as usize;
            // These producer inputs are fixed literal FP32 values, not computed
            // model outputs. Their original real domains have zero error.
            let values = match index {
                4 | 5 => vec![0.0; cells],
                6..=8 => {
                    let magnitude = [3.0, 2.0, 0.5][index - 6];
                    [magnitude, 0.0, 0.0, magnitude].repeat(cells / 4)
                }
                _ => unreachable!("five original numerical inputs"),
            };
            let mut numerical = provider.memory().alloc::<f64>(cells).unwrap();
            provider
                .htod_sync_copy_into_tracked(&values, &mut numerical)
                .unwrap();
            sources.push(numerical.into_bytes().view());
        }
        let publication = Arc::clone(session.publication.as_ref().unwrap());
        let export = |view: DeviceMemoryView<u8>, tensor_layout: SemanticTensorLayout| {
            let rank = tensor_layout.rank as usize;
            export_owned_allocation(
                view,
                tensor_layout.dimensions[..rank]
                    .iter()
                    .map(|&n| n as i64)
                    .collect(),
                tensor_layout.strides_bytes[..rank]
                    .iter()
                    .map(|&n| (n / tensor_layout.element_bytes) as i64)
                    .collect(),
                (
                    if tensor_layout.scalar_type == 8 { 6 } else { 2 },
                    (tensor_layout.element_bytes * 8) as u8,
                ),
                provider.device().ordinal() as i32,
                Arc::new(()),
                Arc::clone(&publication),
                None,
                None,
            )
        };
        let capture = sources
            .iter()
            .cloned()
            .zip(layouts)
            .map(|(view, layout)| SemanticTensorInput {
                tensor: export(view, layout),
                layout,
                logical_begin: 0,
                logical_end: 0,
                native_allocation: None,
            })
            .collect();
        let policy_witness = session.capture_tensor_content(&parent, capture, 1).unwrap();
        let producers = sources
            .into_iter()
            .zip(layouts)
            .map(|(view, layout)| export(view, layout))
            .collect::<Vec<_>>();
        let [logits, support, parameters, component_baselines, numerical @ ..]:
            [DlpackManagedTensor; 9] = producers.try_into().ok().unwrap();
        let rng = session.continuation_rng(&parent).unwrap();
        let original_components = session.device_components.device_ptr_value();
        let original_codebooks = session.device_codebooks.device_ptr_value();
        let before_policy_binding = session.host_io_stats();
        session
            .bind_policy_dlpack(
                &parent,
                session.binding(),
                rng,
                logits,
                support,
                parameters,
                component_baselines,
                numerical,
                &policy_witness,
                1,
            )
            .unwrap();
        assert_eq!(
            session.host_io_stats(),
            before_policy_binding,
            "policy binding must not upload state or immutable catalogue metadata"
        );
        // Original captured producers remain immutable through final use.
        // Distinct device banks prove that the policy owns its snapshots.
        let policy = session.policy.as_ref().unwrap();
        assert_ne!(
            policy.text_logits.device_ptr_value(),
            *original_logit.device_ptr()
        );
        assert_ne!(
            session.support.device_ptr_value(),
            *original_support.device_ptr()
        );
        assert_ne!(
            policy.parameters.device_ptr_value(),
            *original_parameter.device_ptr()
        );
        let read = |view: crate::memory::DeviceMemoryView<f32>| {
            provider.device().inner().dtoh_sync_copy(&view).unwrap()[0]
        };
        assert_eq!(
            read(
                session
                    .policy
                    .as_ref()
                    .unwrap()
                    .text_logits
                    .view()
                    .slice(0..1)
            ),
            2.0
        );
        assert_eq!(
            read(
                session
                    .policy
                    .as_ref()
                    .unwrap()
                    .parameters
                    .view()
                    .slice(0..1)
            ),
            3.0
        );
        assert_eq!(
            provider
                .device()
                .inner()
                .dtoh_sync_copy(&session.support.view().slice(0..1))
                .unwrap(),
            [1u8]
        );
        assert_eq!(session.rng, Some(rng));
        // An unconsumed forward retains its real continuation witness.
        if matches!(completion, PolicyFixtureCompletion::Backward) {
            assert!(session.release(&mut parent, &[1]).is_err());
        }
        session.capture().unwrap();
        let before_launch = session.host_io_stats();
        session.launch().unwrap();
        assert_eq!(session.host_io_stats(), before_launch);
        let outcome = session.observe(0).unwrap();
        assert_eq!(
            session.device_components.device_ptr_value(),
            original_components
        );
        assert_eq!(
            session.device_codebooks.device_ptr_value(),
            original_codebooks
        );
        assert_eq!(
            *session.policy_tapes[0].components.device_ptr(),
            original_components
        );
        assert_eq!(
            *session.policy_tapes[0].codebooks.device_ptr(),
            original_codebooks
        );
        match (&completion, &outcome) {
            (
                PolicyFixtureCompletion::NumericalRefusal,
                SemanticTransitionOutcome::Refused(
                    SemanticTransitionRefusal::NonFinitePolicyInput { completed_draws: 0 },
                ),
            ) => {}
            (
                PolicyFixtureCompletion::Backward | PolicyFixtureCompletion::Inference,
                SemanticTransitionOutcome::Published(_),
            ) => {}
            _ => panic!("policy fixture returned the wrong native outcome: {outcome:?}"),
        }
        let parent_identity = session.retained_step_identity(&parent).unwrap();
        session.release_published_reader(&mut parent, &[1]).unwrap();
        assert!(!parent.active && !session.readers.contains_key(&parent.token));
        assert_eq!(
            session.retained_step_identity(&parent).unwrap(),
            parent_identity
        );
        assert!(session.published_identity(&parent).is_err());
        if !matches!(completion, PolicyFixtureCompletion::Backward) {
            let mut foreign_session =
                super::text_parent_tests::publication_test_session(Arc::clone(&provider), &domain);
            foreign_session
                .bind_parent(super::text_parent_tests::publication_test_parent(&provider))
                .unwrap();
            let mut foreign_parent = foreign_session.acquire().unwrap();
            let parent_identity = session.retained_step_identity(&parent).unwrap();
            let witness_owners = Arc::strong_count(&session.steps[&parent.token].content_witnesses);
            assert!(witness_owners > 1);
            assert_eq!(session.policy_tapes.len(), 1);
            assert_eq!(session.policy_tapes[0].invocation, rng);
            let before_final_use = session.host_io_stats();
            for invalid_stream in [0, 2] {
                assert!(session
                    .finish_policy_invocation(&parent, rng, invalid_stream)
                    .is_err());
                assert_eq!(session.policy_tapes.len(), 1);
                assert_eq!(session.policy_tapes[0].invocation, rng);
                assert_eq!(
                    Arc::strong_count(&session.steps[&parent.token].content_witnesses),
                    witness_owners
                );
            }
            assert!(session
                .finish_policy_invocation(&foreign_parent, rng, 1)
                .is_err());
            assert_eq!(session.policy_tapes.len(), 1);
            assert_eq!(session.policy_tapes[0].invocation, rng);
            assert_eq!(
                Arc::strong_count(&session.steps[&parent.token].content_witnesses),
                witness_owners
            );
            assert_eq!(
                session.retained_step_identity(&parent).unwrap(),
                parent_identity
            );
            session.finish_policy_invocation(&parent, rng, 1).unwrap();
            assert!(session.policy_tapes.is_empty());
            assert!(session.steps[&parent.token].consumer_streams.contains(&1));
            assert_eq!(
                session.host_io_stats(),
                before_final_use,
                "inference final use must use original device guards and stream events only"
            );
            let retained_witness_owners =
                Arc::strong_count(&session.steps[&parent.token].content_witnesses);
            assert!(retained_witness_owners > 1 && !parent.active);
            assert!(session.finish_policy_invocation(&parent, rng, 1).is_err());
            assert_eq!(
                Arc::strong_count(&session.steps[&parent.token].content_witnesses),
                retained_witness_owners
            );
            assert_eq!(
                session.retained_step_identity(&parent).unwrap(),
                parent_identity
            );
            drop(witness);
            drop(policy_witness);
            drop((original_logit, original_support, original_parameter));
            drop(outcome);
            assert_eq!(
                Arc::strong_count(&session.steps[&parent.token].content_witnesses),
                1
            );
            session.release(&mut parent, &[1]).unwrap();
            assert!(!parent.active && !session.readers.contains_key(&parent.token));
            assert!(!session.is_poisoned());
            foreign_session.release(&mut foreign_parent, &[1]).unwrap();
            return;
        }
        let mut coefficients = provider.memory().alloc::<f64>(COMPONENT_COUNT).unwrap();
        provider
            .htod_sync_copy_into_tracked(&vec![1.0f64; COMPONENT_COUNT], &mut coefficients)
            .unwrap();
        let buffer = provider
            .buffer_from_columns(
                vec![CudaColumn::Owned(coefficients.into_bytes())],
                COMPONENT_COUNT as u64,
                Schema::new(vec![("cotangent".into(), ScalarType::F64)]),
            )
            .unwrap();
        let cotangents = provider.to_dlpack_table(buffer).column(0).unwrap();
        let before_backward = session.host_io_stats();
        let gradients = session.backward_policy_dlpack(rng, cotangents, 1).unwrap();
        let parameter_pointer = gradients.parameters.device_ptr_value();
        let text_pointer = gradients.text_logits.device_ptr_value();
        let [parameters, text, numerical @ ..] = gradients.into_dlpack().unwrap();
        assert_eq!(
            session.host_io_stats(),
            before_backward,
            "backward and original gradient exports must use device guards and stream events only"
        );
        // SAFETY: both managed owners retain these complete immutable DLPack
        // descriptors and their real backward allocations during inspection.
        unsafe {
            let parameter_tensor = &(*parameters.as_ptr()).dl_tensor;
            let text_tensor = &(*text.as_ptr()).dl_tensor;
            assert_eq!((parameter_tensor.ndim, text_tensor.ndim), (1, 2));
            assert!(
                !parameter_tensor.shape.is_null()
                    && !text_tensor.shape.is_null()
                    && !text_tensor.strides.is_null()
            );
            assert_eq!(
                std::slice::from_raw_parts(parameter_tensor.shape, 1),
                [layout.parameter_cells as i64]
            );
            assert_eq!(
                std::slice::from_raw_parts(text_tensor.shape, 2),
                [32, TEXT_CARDINALITY as i64]
            );
            assert_eq!(
                std::slice::from_raw_parts(text_tensor.strides, 2),
                [TEXT_CARDINALITY as i64, 1]
            );
            assert_eq!(parameter_tensor.data as usize as u64, parameter_pointer);
            assert_eq!(text_tensor.data as usize as u64, text_pointer);
            assert_eq!(
                (
                    text_tensor.dtype.code,
                    text_tensor.dtype.bits,
                    text_tensor.dtype.lanes
                ),
                (2, 32, 1)
            );
            assert_eq!(
                text_tensor.device.device_id,
                provider.device().ordinal() as i32
            );
            let dimensions = [
                vec![1, COMPONENT_COUNT as i64],
                vec![layout.parameter_cells as i64, 2],
                vec![32, TEXT_CARDINALITY as i64, 2],
                vec![1, COMPONENT_COUNT as i64, 2],
                vec![2, layout.parameter_cells as i64, 4],
                vec![2, 32, TEXT_CARDINALITY as i64, 4],
                vec![2, 1, COMPONENT_COUNT as i64, 4],
            ];
            for (index, (tensor, dimensions)) in numerical.iter().zip(dimensions).enumerate() {
                let tensor = &(*tensor.as_ptr()).dl_tensor;
                assert_eq!(tensor.ndim as usize, dimensions.len());
                assert!(!tensor.shape.is_null());
                assert_eq!(
                    std::slice::from_raw_parts(tensor.shape, dimensions.len()),
                    dimensions
                );
                assert_eq!(
                    (tensor.dtype.code, tensor.dtype.bits, tensor.dtype.lanes),
                    (2, if index == 0 { 32 } else { 64 }, 1)
                );
                assert_eq!(tensor.device.device_id, provider.device().ordinal() as i32);
            }
        }
        assert!(session.steps[&parent.token].consumer_streams.contains(&1));
        assert!(
            session.release(&mut parent, &[1]).is_err(),
            "live gradient owners retain their original parent"
        );
        drop(parameters);
        drop(text);
        assert!(
            session.release(&mut parent, &[1]).is_err(),
            "baseline and numerical gradient owners retain their original parent"
        );
        drop(numerical);
        drop(witness);
        drop(policy_witness);
        drop((original_logit, original_support, original_parameter));
        drop(outcome);
        session.release(&mut parent, &[1]).unwrap();
        assert!(session.retained_step_identity(&parent).is_err());
        drop(session);
    }

    #[test]
    fn semantic_work_accepts_refused_prefixes_and_rejects_impossible_effects() {
        for (edit_commands, added_supports, defined_truth_changes, valid) in [
            (0, 0, 0, true), // NO_EDIT only
            (1, 0, 0, true), // duplicate or refusal without mutation
            (2, 1, 0, true), // one attachment, then duplicate or refusal
            (2, 2, 1, true), // NEITHER -> TRUE -> BOTH
            (2, 2, 2, true), // edits to two already defined statements
            (3, 0, 0, false),
            (0, 1, 0, false),
            (1, 2, 0, false),
            (1, 1, 2, false),
            (u64::MAX, 0, 0, false),
        ] {
            let work = SemanticTransitionWork {
                edit_commands,
                added_supports,
                defined_truth_changes,
            };
            assert_eq!(work.is_valid(false), valid, "{work:?}");
        }
    }

    #[test]
    fn editable_program_work_counts_materialized_facts_and_bounds_signed_return() {
        let work = SemanticTransitionWork {
            edit_commands: 2,
            added_supports: crate::semantic_program::RESIDENT_PROGRAM_FACT_CAPACITY as u64,
            defined_truth_changes: 3,
        };
        assert!(!work.is_valid(false));
        assert!(work.is_valid(true));
        assert!(!SemanticTransitionWork {
            added_supports: work.added_supports + 1,
            ..work
        }
        .is_valid(true));
        let scoring = SemanticTaskScoring {
            correct_weight: 14,
            all_correct_weight: 7,
            work_weight: 1,
            improvement_weight: 45,
            refusal_weight: 15,
            spent_weight: 1,
        };
        assert_eq!(scoring.return_bound(false).unwrap(), 2522);
        assert_eq!(scoring.return_bound(true).unwrap(), 186799);
    }

    #[test]
    fn structural_cost_law_tracks_program_mode_without_task_identity() {
        let graph = semantic_structural_cost_descriptor(false);
        let editable = semantic_structural_cost_descriptor(true);
        assert_eq!(graph.cap, 6);
        assert_eq!(editable.cap, 4101);
        assert_ne!(graph.unit, editable.unit);
        assert_ne!(graph.unit, Identity256::default());
        assert_eq!(graph, semantic_structural_cost_descriptor(false));
        assert_eq!(editable, semantic_structural_cost_descriptor(true));
        let maximum = SemanticTransitionWork {
            edit_commands: 2,
            added_supports: 4096,
            defined_truth_changes: 3,
        };
        assert_eq!(maximum.raw_structural_cost(), editable.cap);
        assert_eq!(SemanticTransitionWork::default().raw_structural_cost(), 0);
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn candidate_resource_refusals_preserve_the_completed_base() {
        let scoring = SemanticTaskScoring {
            correct_weight: 0,
            all_correct_weight: 0,
            work_weight: 1,
            improvement_weight: 0,
            refusal_weight: 1,
            spent_weight: 0,
        };
        let facts = [
            SemanticTaskFacts {
                eligible: 1,
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts {
                c: 1,
                v: -1,
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts::default(),
        ];
        let work = [
            SemanticTransitionWork {
                edit_commands: 1,
                ..SemanticTransitionWork::default()
            },
            SemanticTransitionWork::default(),
        ];
        assert!(validate_completed_task_scoring(
            scoring,
            true,
            &[],
            &facts,
            &work,
            [3, 4],
            3,
            0,
            -2,
        ));
        assert!(!validate_completed_task_scoring(
            scoring,
            true,
            &[],
            &facts,
            &work,
            [3, 5],
            3,
            0,
            -2,
        ));
        assert!(!validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &facts,
            &work,
            [3, 4],
            3,
            0,
            -2,
        ));
        assert_eq!(
            SemanticTaskRefusal::FactCapacity.canonical_kind(),
            "fact-capacity"
        );
        assert_eq!(
            SemanticTaskRefusal::FuelExhausted.canonical_kind(),
            "fuel-exhausted"
        );
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn completed_scoring_accepts_program_materialization_cost() {
        let scoring = SemanticTaskScoring {
            correct_weight: 14,
            all_correct_weight: 7,
            work_weight: 1,
            improvement_weight: 45,
            refusal_weight: 15,
            spent_weight: 1,
        };
        let work = SemanticTransitionWork {
            edit_commands: 2,
            added_supports: crate::semantic_program::RESIDENT_PROGRAM_FACT_CAPACITY as u64,
            defined_truth_changes: 3,
        };
        let facts = [
            SemanticTaskFacts {
                eligible: 1,
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts {
                truth: [1; 3],
                correct: [1; 3],
                g: 3,
                p: 1,
                c: 4101,
                v: -4052,
                eligible: 1,
            },
            SemanticTaskFacts::default(),
        ];
        let work = [work, SemanticTransitionWork::default()];
        assert!(validate_completed_task_scoring(
            scoring,
            true,
            &[],
            &facts,
            &work,
            [0, 1],
            6,
            1,
            -182361,
        ));
        assert!(!validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &facts,
            &work,
            [0, 1],
            6,
            1,
            -182361,
        ));
    }

    #[test]
    fn policy_storage_follows_native_codebooks_without_allocating_null_embeddings() {
        let layout = SemanticPolicyLayout::from_components(COMPONENTS).unwrap();
        assert_eq!(layout.z, 0..4 * 128);
        assert_eq!(layout.recurrence, layout.z.end..layout.z.end + 128 * 128);
        assert_eq!(
            layout.positions,
            layout.recurrence.end..layout.recurrence.end + 18 * 128
        );
        let mut cursor = layout.positions.end;
        for (field, component) in layout.fields.iter().zip(&COMPONENTS[32..50]) {
            let cardinality = component.cardinality as usize;
            let null = component.field != 0;
            assert_eq!(field.null_category, if null { Some(0) } else { None });
            assert_eq!(field.cardinality, cardinality);
            assert_eq!(
                field.embeddings,
                cursor..cursor + (cardinality - usize::from(null)) * 128
            );
            cursor = field.embeddings.end;
            let bias_count = if null && cardinality == 1 {
                0
            } else {
                cardinality
            };
            assert_eq!(field.biases, cursor..cursor + bias_count);
            cursor = field.biases.end;
        }
        assert_eq!(layout.parameter_cells, cursor);
        assert_eq!(layout.recurrent_cells(), 2 * 37 * 128);
        assert_eq!(
            layout.score_cells(),
            COMPONENTS[32..50]
                .iter()
                .map(|c| c.cardinality as usize)
                .max()
                .unwrap()
        );
    }

    #[test]
    fn resident_ranges_reject_partial_overlap_overflow_and_empty_storage() {
        assert!(disjoint_ranges(&[(8, 16), (24, 8)]).is_ok());
        for ranges in [
            [(8, 16), (16, 16)],
            [(8, 16), (8, 8)],
            [(8, 16), (u64::MAX, 8)],
            [(8, 0), (16, 8)],
        ] {
            assert_eq!(
                disjoint_ranges(&ranges),
                Err(SemanticTransitionError::OverlappingInputs)
            );
        }
    }

    #[test]
    fn policy_layout_tracks_admitted_cardinality_and_rejects_inconsistent_slots() {
        let mut components = COMPONENTS.to_vec();
        for lane in 0..2 {
            for slot in 0..2 {
                components[lane * 68 + 32 + slot * 18 + 2].cardinality = 7;
            }
        }
        let layout = SemanticPolicyLayout::from_components(&components).unwrap();
        assert_eq!(layout.fields[2].embeddings.len(), 6 * 128);
        assert_eq!(layout.fields[2].biases.len(), 7);
        assert_eq!(layout.fields[2].null_category, Some(0));
        assert_eq!(layout.fields[0].null_category, None);
        assert_eq!(
            layout.fields[0].embeddings.len(),
            layout.fields[0].cardinality * 128
        );
        components[32 + 18 + 2].cardinality = 6;
        assert!(SemanticPolicyLayout::from_components(&components).is_err());
        assert!(SemanticPolicyLayout::from_components(&COMPONENTS[..135]).is_err());
        let mut malformed = COMPONENTS.to_vec();
        malformed[32].lane = 0;
        assert!(SemanticPolicyLayout::from_components(&malformed).is_err());
        malformed[32] = COMPONENTS[32];
        malformed[32].cardinality = 0;
        assert!(SemanticPolicyLayout::from_components(&malformed).is_err());
    }

    #[test]
    fn decoded_support_corruption_rolls_back_first_lane_and_poison_closes_session() {
        use crate::{
            SemanticPolarity, SemanticPredicateRecord, SemanticRecordRole, SemanticSupportRecord,
            SemanticTypedRecord,
        };
        use cudarc::nvrtc::Ptx;
        use xlog_core::{RelId, Schema};
        if std::env::var("XLOG_REQUIRE_CUDA").as_deref() != Ok("1") {
            return;
        }
        #[derive(Clone, Copy)]
        enum IntegrityFault {
            SecondEdit,
            AfterSealedLane,
            RefusedEditThenInvalidLogit,
        }
        for fault_case in [
            IntegrityFault::SecondEdit,
            IntegrityFault::AfterSealedLane,
            IntegrityFault::RefusedEditThenInvalidLogit,
        ] {
            let late_failure = matches!(fault_case, IntegrityFault::AfterSealedLane);
            let refused_then_invalid =
                matches!(fault_case, IntegrityFault::RefusedEditThenInvalidLogit);
            let global_failure = late_failure || refused_then_invalid;
            let provider =
                crate::CudaProviderBuilder::new(0, MemoryBudget::with_limit(256 * 1024 * 1024))
                    .with_stream_capacity(1)
                    .build()
                    .unwrap();
            let provider = Arc::new(provider);
            let runtime = Arc::clone(provider.memory().runtime().unwrap());
            let id = runtime.stream_pool().acquire().unwrap();
            let stream = runtime.stream_pool().resolve(id).unwrap();
            let domain = provider
                .bind_resident_execution_domain(runtime, id, stream)
                .unwrap();
            let mut graph = provider
                .allocate_semantic_hypergraph(
                    &domain,
                    SemanticHypergraphCapacities::try_new(3, 4, 4, 4).unwrap(),
                )
                .unwrap();
            let base = graph.empty_root();
            let roles = [
                SemanticRecordRole::Statement,
                SemanticRecordRole::Provenance,
                SemanticRecordRole::Source,
                SemanticRecordRole::Context,
                SemanticRecordRole::Scope,
            ];
            graph
                .admit_records(
                    base,
                    SemanticAdmissionRecords {
                        predicates: roles
                            .into_iter()
                            .enumerate()
                            .map(|(i, role)| SemanticPredicateRecord {
                                predicate: RelId(i as u32),
                                role,
                                schema: Schema::new(vec![]),
                            })
                            .collect(),
                        records: (0..5)
                            .map(|i| SemanticTypedRecord {
                                predicate: RelId(i),
                                arguments: vec![],
                                qualifiers: vec![],
                            })
                            .collect(),
                        supports: vec![SemanticSupportRecord {
                            statement: 0,
                            polarity: SemanticPolarity::Pro,
                            provenance: 1,
                            source: 2,
                            context: 3,
                            scope: 4,
                        }],
                    },
                    SemanticAdmissionLimits {
                        max_records: 12,
                        max_terms: 0,
                        max_references: 5,
                        max_utf8_bytes: 0,
                    },
                )
                .unwrap();
            let mut session = SemanticTransitionSession::from_hypergraph(graph).unwrap();

            // Immutable typed inputs cannot produce an invalid polarity. Inject
            // faults in this compilation of the production kernel; actual sampler,
            // mutation and cleanup remain unchanged. These are integrity failures,
            // not semantic policy refusals.
            let source = include_str!("../kernels/semantic_transition.cu");
            let anchor = if late_failure {
                "lane_live=candidate.words[41]!=0;"
            } else {
                "decode_action(books,choices,&statement,&event);"
            };
            assert_eq!(source.matches(anchor).count(), 1);
            let fault = if late_failure {
                "if (lane==1) {failed=1;state->status=3;}"
            } else if refused_then_invalid {
                "if (lane==0 && component.slot==0) event.polarity=0;"
            } else {
                "if (lane==0 && component.slot==1) event.polarity=0;"
            };
            let source = source.replacen(anchor, &format!("{anchor}\n{fault}"), 1);
            // Use the same ahead-of-time compiler as the normal kernel build. NVRTC
            // does not supply the standard headers included by this canonical source.
            struct CompilationFiles(std::path::PathBuf);
            impl Drop for CompilationFiles {
                fn drop(&mut self) {
                    for file in ["transition.cu", "transition.ptx"] {
                        if let Err(error) = std::fs::remove_file(self.0.join(file)) {
                            if error.kind() != std::io::ErrorKind::NotFound {
                                eprintln!("failed to remove test compiler output: {error}");
                            }
                        }
                    }
                    if let Err(error) = std::fs::remove_dir(&self.0) {
                        eprintln!("failed to remove test compiler directory: {error}");
                    }
                }
            }
            let unique = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos();
            let path = std::env::temp_dir().join(format!(
                "xlog-decoded-support-{}-{unique}",
                std::process::id()
            ));
            std::fs::create_dir(&path).unwrap();
            let files = CompilationFiles(path);
            std::fs::write(files.0.join("transition.cu"), source).unwrap();
            let output = std::process::Command::new(
                std::env::var_os("NVCC_PATH").unwrap_or_else(|| "nvcc".into()),
            )
            .args([
                "--ptx",
                "-arch=sm_75",
                "-O3",
                "-std=c++17",
                "-I",
                env!("OUT_DIR"),
                "-I",
                concat!(env!("CARGO_MANIFEST_DIR"), "/kernels"),
            ])
            .arg(files.0.join("transition.cu"))
            .arg("-o")
            .arg(files.0.join("transition.ptx"))
            .output()
            .expect("compile canonical transition with decoded support corruption");
            assert!(
                output.status.success(),
                "{}",
                String::from_utf8_lossy(&output.stderr)
            );
            let ptx =
                Ptx::from_src(std::fs::read_to_string(files.0.join("transition.ptx")).unwrap());
            drop(files);
            let device = provider.device().inner();
            let module = "semantic_transition_decoded_support_corruption";
            device
                .load_ptx(ptx, module, &["semantic_transition_execute"])
                .unwrap();
            session.execute = device
                .get_func(module, "semantic_transition_execute")
                .unwrap();
            let inputs: Vec<_> = session
                .components()
                .iter()
                .map(|component| {
                    let mut product_support = vec![0; component.cardinality as usize];
                    let choice = usize::from(
                        !component.is_text() && matches!(component.field, 0 | 1 | 2 | 11 | 17),
                    );
                    product_support[choice] = 1;
                    SemanticComponentInput {
                        logits: vec![0.; product_support.len()],
                        product_support,
                    }
                })
                .collect();
            session
                .bind_inputs(
                    session.binding(),
                    SemanticRngBinding {
                        model_generation: 1,
                        stream_serial: 1,
                        family_id: 1,
                        proposal: 0,
                    },
                    &inputs,
                )
                .unwrap();
            if refused_then_invalid {
                // Corrupt the retained bank only after valid cold binding. The
                // second edit's first conditional factor then fails through the
                // production nonfinite-logit check, after a genuine edit refusal
                // has retained its candidate acquisition for cleanup.
                let mut corrupted_logits: Vec<_> = inputs
                    .iter()
                    .flat_map(|input| input.logits.iter().copied())
                    .collect();
                let component = session.components()[50];
                assert_eq!((component.lane, component.slot, component.field), (1, 1, 0));
                corrupted_logits[component.offset as usize + 1] = f32::NAN;
                provider
                    .htod_sync_copy_into_tracked(&corrupted_logits, &mut session.logits)
                    .unwrap();
            }
            let [arena_ptr, _, root_capacity, statement_capacity, _, _, arena_words] =
                session.graph.transition_arena();
            assert_eq!(
                (root_capacity, statement_capacity, arena_words),
                (3, 4, 260)
            );
            assert_eq!(base.slot(), 0);
            let readback_stream = Arc::clone(&session.stream);
            let read_resident_arena = || {
                readback_stream.synchronize().unwrap();
                let mut words = vec![0u64; arena_words as usize];
                // SAFETY: the session still owns this entire allocation; its stream
                // is idle and the destination has exactly the advertised capacity.
                assert_eq!(
                    unsafe {
                        sys::cuMemcpyDtoH_v2(
                            words.as_mut_ptr().cast(),
                            arena_ptr,
                            std::mem::size_of_val(words.as_slice()),
                        )
                    },
                    sys::cudaError_enum::CUDA_SUCCESS
                );
                words
            };
            // Diagnostic I/O stays outside capture and the measured launch interval.
            // Read the device allocation itself, never the cached base_snapshot.
            let original_arena = read_resident_arena();
            // Canonical layout: sixteen control words, then sixteen words per root;
            // root statement heads precede the final candidate statement-head array.
            let base_record = 16..32;
            let heads_start = (arena_words - (root_capacity + 1) * statement_capacity) as usize;
            let base_heads = heads_start..heads_start + statement_capacity as usize;
            assert_eq!(&original_arena[19..22], &[0, 0, 0]);
            assert!(original_arena[base_heads.clone()]
                .iter()
                .all(|head| *head == 0));
            session.capture().unwrap();
            assert_eq!(session.captured.as_ref().unwrap().node_count().unwrap(), 1);
            let before = session.host_io_stats();
            session.launch().unwrap();
            assert_eq!(session.host_io_stats(), before);
            let error = session.observe(0).unwrap_err();
            if refused_then_invalid {
                assert!(matches!(
                    error,
                    SemanticTransitionError::NonFinitePolicyInput {
                        completed_draws: 50
                    }
                ));
            } else if late_failure {
                assert!(matches!(
                    error,
                    SemanticTransitionError::ObservationMismatch
                ));
            } else {
                assert!(matches!(error, SemanticTransitionError::Semantic(_)));
            }
            assert!(session.is_poisoned());
            assert_eq!(
                session.next_proposal, 0,
                "integrity error must not publish RNG successor"
            );
            assert!(matches!(
                session.launch(),
                Err(SemanticTransitionError::Poisoned)
            ));
            assert!(matches!(
                session.observe(0),
                Err(SemanticTransitionError::Poisoned)
            ));

            // SAFETY: observe completed both copies and stream waits before decoding
            // the integrity failure. Inspect that same terminal bank, with no new I/O.
            let (state, components) = unsafe { session.pinned.read() }.unwrap();
            if global_failure {
                assert_eq!(
                    (state.status, state.blocks, state.next_proposal),
                    if late_failure { (3, 68, 0) } else { (5, 50, 0) }
                );
                if late_failure {
                    assert_eq!(state.semantic_receipts[3][1], 1, "first lane really sealed");
                    assert_eq!(state.retired_roots_mask, 1);
                    assert_eq!(state.cleanup_receipts[1][0], 0, "sealed root reclaimed");
                } else {
                    assert_eq!(
                        state.semantic_receipts[1][0], 12,
                        "original edit refusal retained"
                    );
                    assert_eq!(&state.semantic_receipts[1][40..42], &[0, 1]);
                    assert_eq!(state.retired_roots_mask, 0, "no root was sealed");
                }
                assert_eq!(state.cleanup_receipts[0][0], 0, "live candidate discarded");
                assert_eq!(&state.cleanup_receipts[0][40..42], &[0, 0]);
                let terminal_arena = read_resident_arena();
                assert_eq!(
                    &terminal_arena[base_record.clone()],
                    &original_arena[base_record]
                );
                assert_eq!(
                    &terminal_arena[base_heads.clone()],
                    &original_arena[base_heads]
                );
                for slot in [32, 48, 64] {
                    assert_eq!(terminal_arena[slot], 0, "no pending root or candidate");
                }
                drop(session);
                provider.memory().reap_pending_deallocations().unwrap();
                assert_eq!(provider.memory().allocated_bytes(), 0);
                assert_eq!(provider.memory().deallocation_failure_bytes(), 0);
                continue;
            }
            assert_eq!((state.status, state.blocks), (0, 136));
            for (row, component) in components.iter().zip(session.components()) {
                assert_eq!(row.ordinal, component.ordinal);
                assert_eq!(row.admission_binding, session.binding().digest);
                assert_eq!(
                    row.choice,
                    u32::from(
                        !component.is_text() && matches!(component.field, 0 | 1 | 2 | 11 | 17)
                    )
                );
                assert_eq!(
                    (row.cdf_start, row.cdf_end, row.mass),
                    (0, 1 << 63, 1 << 63)
                );
                assert!(row.draw < row.cdf_end);
            }
            let receipts = state.semantic_receipts;
            assert_eq!(receipts[0][0], 0); // Acquired-base preflight succeeded.
            assert_eq!(&receipts[0][13..16], &[0, 0, 0]);
            assert_eq!(&receipts[1][0..3], &[0, 1, 1]); // First actual insertion.
            assert_eq!(receipts[2][0], 12); // Invalid second decoded support.
            assert_eq!(receipts[3][0], 12); // Refusal survives discard/seal.
            assert_eq!(&receipts[3][40..42], &[0, 1]); // Original refusal diagnostic retained.
            assert_eq!(&receipts[4][0..3], &[0, 1, 1]); // Next lane executes.
            assert_eq!(&receipts[5][0..3], &[0, 2, 1]); // Then exact duplicate.
            assert_eq!(&receipts[4][40..42], &[0, 2]); // Discarded candidate reused safely.
            assert_eq!(&receipts[5][40..42], &[0, 2]);
            assert_eq!(receipts[6][0], 0);
            assert_eq!(&receipts[6][13..16], &[1, 1, 1]);
            assert_eq!(receipts[6][6], 3); // Successful terminal retires the candidate again.
            assert_eq!(&receipts[6][3..5], &[1, 1]); // No root published by the failed lane.
            for slot in [7, 9, 11] {
                assert_eq!(receipts[4][slot], receipts[1][slot]);
                assert!(receipts[4][slot + 1] > receipts[1][slot + 1]);
            }
            // Observe has completed the failed lane's cleanup and the successful
            // next lane. Re-read resident state even though public observation is
            // now poison-closed. For this empty base, zero heads exhaust reachable
            // content; other roots and globally reused records may legitimately change.
            let terminal_arena = read_resident_arena();
            assert_eq!(&terminal_arena[..16], &original_arena[..16]);
            assert_eq!(
                &terminal_arena[base_record.clone()],
                &original_arena[base_record]
            );
            assert_eq!(
                &terminal_arena[base_heads.clone()],
                &original_arena[base_heads]
            );
            drop(session);
            provider.memory().reap_pending_deallocations().unwrap();
            assert_eq!(provider.memory().allocated_bytes(), 0);
            assert_eq!(provider.memory().deallocation_failure_bytes(), 0);
        }
    }

    #[test]
    fn actual_enqueued_work_and_terminal_wait_faults_poison_public_session() {
        if std::env::var("XLOG_REQUIRE_CUDA").as_deref() != Ok("1") {
            return;
        }
        let provider =
            crate::CudaProviderBuilder::new(0, MemoryBudget::with_limit(256 * 1024 * 1024))
                .with_stream_capacity(1)
                .build()
                .unwrap();
        let provider = Arc::new(provider);
        let runtime = Arc::clone(provider.memory().runtime().unwrap());
        let id = runtime.stream_pool().acquire().unwrap();
        let stream = runtime.stream_pool().resolve(id).unwrap();
        let domain = provider
            .bind_resident_execution_domain(runtime, id, stream)
            .unwrap();
        for failure in 0..12 {
            let mut session = SemanticTransitionSession::new(&provider, &domain).unwrap();
            let inputs: Vec<_> = session
                .components()
                .iter()
                .map(|c| {
                    let mut mask = vec![0; c.cardinality as usize];
                    mask[0] = 1;
                    SemanticComponentInput {
                        logits: vec![0.; mask.len()],
                        product_support: mask,
                    }
                })
                .collect();
            session
                .bind_inputs(
                    session.binding(),
                    SemanticRngBinding {
                        model_generation: 1,
                        stream_serial: 2,
                        family_id: 3,
                        proposal: 4,
                    },
                    &inputs,
                )
                .unwrap();
            session.capture().unwrap();
            assert_eq!(session.captured.as_ref().unwrap().node_count().unwrap(), 1);
            if failure == 0 {
                let recorder = session.kernel_recorder();
                let graph = session.captured.as_ref().unwrap();
                let result = enqueue_recorded(&domain, &mut session.poisoned, recorder, |stream| {
                    graph.launch_in(stream)?;
                    Err::<(), _>(XlogError::Kernel(
                        "injected error after actual graph enqueue".into(),
                    ))
                });
                assert!(result.is_err());
            } else if failure == 1 {
                session.launch().unwrap();
                let result = wait_on_stream(
                    &session.stream,
                    &mut session.poisoned,
                    &mut session.stream_waits,
                    "terminal wait",
                    |stream| {
                        stream.synchronize().unwrap();
                        Err::<(), _>(XlogError::Kernel(
                            "injected terminal wait error after actual completion".into(),
                        ))
                    },
                );
                assert!(result.is_err());
            } else if failure == 2 {
                // Exercise the actual device-side rejection and typed observation:
                // corrupt a private cold state binding after public preflight.
                let invalid = DeviceState {
                    next_proposal: 4,
                    ..DeviceState::default()
                };
                provider
                    .htod_sync_copy_into_tracked(&[invalid], &mut session.state)
                    .unwrap();
                session.launch().unwrap();
                assert!(matches!(
                    session.observe(4),
                    Err(SemanticTransitionError::ObservationMismatch)
                ));
            } else if failure == 3 {
                // A captured-but-never-launched session must release its storage.
                assert!(!session.is_poisoned());
            } else if failure == 4 {
                // Repeated capture and a normal terminal observation also retire
                // all read dependencies without carrying capture-only events.
                session.capture().unwrap();
                session.launch().unwrap();
                session.observe(4).unwrap();
            } else if failure == 5 {
                // Internal integrity diagnostics must close the enclosing owner,
                // not merely appear as a nested lane error permitting replay.
                let mut words = [0; 42];
                words[0] = 11;
                assert!(session.graph.observe_transition_edit(words).is_err());
            } else if failure == 6 {
                let mut words = [0; 42];
                words[3] = u64::MAX;
                assert!(session.graph.observe_transition_root(words).is_err());
            } else {
                let mut words = [0; 42];
                words[1] = if failure == 11 { 2 } else { 1 };
                words[8] = 1;
                words[10] = 1;
                words[12] = 1;
                words[39] = session.graph.transition_arena()[1];
                match failure {
                    7 => words[39] = 0,
                    8 => words[8] = 0,
                    9 => words[10] = 0,
                    _ => words[12] = 0,
                }
                assert!(session.graph.observe_transition_edit(words).is_err());
            }
            if !(3..5).contains(&failure) {
                assert!(session.is_poisoned());
                assert!(matches!(
                    session.launch(),
                    Err(SemanticTransitionError::Poisoned)
                ));
                assert!(matches!(
                    session.observe(4),
                    Err(SemanticTransitionError::Poisoned)
                ));
            }
            drop(session);
            provider.memory().reap_pending_deallocations().unwrap();
            assert_eq!(provider.memory().allocated_bytes(), 0);
            assert_eq!(provider.memory().deallocation_failure_bytes(), 0);
        }
    }
}

#[cfg(test)]
mod text_parent_tests {
    use super::*;

    #[test]
    fn model_content_snapshot_copies_original_seals_and_exact_contract_interval() {
        let directory = [
            PublicationRange {
                role: 18,
                generation: 1,
                length_bytes: 4,
                ..PublicationRange::default()
            },
            PublicationRange {
                role: 44,
                generation: 1,
                storage_slot: 2,
                offset_bytes: 7,
                length_bytes: 11,
                ..PublicationRange::default()
            },
            PublicationRange {
                role: 20,
                generation: 1,
                length_bytes: 4,
                ..PublicationRange::default()
            },
        ];
        let plan = model_content_copy_plan(&directory, &[2, 0], &[4, 4, 19]).unwrap();
        assert_eq!(
            plan.directory_offsets,
            [
                2 * size_of::<PublicationRange>(),
                0,
                size_of::<PublicationRange>()
            ]
        );
        assert_eq!(plan.contract_storage_slot, 2);
        assert_eq!(plan.contract_span, 7..18);
        let mut changed = directory;
        changed[1].digest = Identity256::from_bytes([91; 32]);
        let changed_plan = model_content_copy_plan(&changed, &[2, 0], &[4, 4, 19]).unwrap();
        assert_eq!(
            changed_plan.directory_offsets, plan.directory_offsets,
            "copy geometry must not upload a host-cached expected digest"
        );
    }

    #[test]
    fn model_content_snapshot_refuses_incomplete_or_unowned_ranges() {
        let directory = [
            PublicationRange {
                role: 18,
                generation: 1,
                length_bytes: 4,
                ..PublicationRange::default()
            },
            PublicationRange {
                role: 44,
                generation: 1,
                storage_slot: 1,
                offset_bytes: 3,
                length_bytes: 5,
                ..PublicationRange::default()
            },
        ];
        let plan = |rows: &[PublicationRange], indices: &[usize], allocations: &[usize]| {
            model_content_copy_plan(rows, indices, allocations)
        };
        assert!(plan(&directory, &[], &[4, 8]).is_err());
        assert!(plan(&directory, &[2], &[4, 8]).is_err());
        assert!(plan(&directory, &[1], &[4, 8]).is_err());
        assert!(plan(&directory, &[0, 0], &[4, 8]).is_err());
        assert!(plan(&directory[..1], &[0], &[4, 8]).is_err());
        assert!(plan(&directory, &[0], &[4]).is_err());
        assert!(plan(&directory, &[0], &[4, 7]).is_err());
        let mut changed = directory;
        changed[1].offset_bytes = u64::MAX;
        assert!(plan(&changed, &[0], &[4, usize::MAX]).is_err());
        changed = directory;
        changed[1].length_bytes = 0;
        assert!(plan(&changed, &[0], &[4, 8]).is_err());
        changed = directory;
        changed[1].generation = 2;
        assert!(plan(&changed, &[0], &[4, 8]).is_err());
        changed = directory;
        changed[1].index = 1;
        assert!(plan(&changed, &[0], &[4, 8]).is_err());
        let duplicate = [directory[0], directory[1], directory[1]];
        assert!(plan(&duplicate, &[0], &[4, 8]).is_err());
    }

    #[test]
    fn model_content_binding_requires_the_complete_original_roster() {
        let layout = |role, index| SemanticTensorLayout {
            role,
            index,
            scalar_type: 6,
            element_bytes: 4,
            rank: 2,
            logical_axis: u64::MAX,
            dimensions: [2, 3, 0, 0],
            strides_bytes: [12, 4, 0, 0],
        };
        let layouts: BTreeMap<_, _> = [(18, 0), (18, 1), (19, 0), (20, 0)]
            .into_iter()
            .map(|key| (key, layout(key.0, key.1)))
            .collect();
        let mut directory: Vec<_> = layouts
            .values()
            .map(|layout| PublicationRange {
                role: layout.role,
                index: layout.index,
                generation: 1,
                length_bytes: 24,
                ..PublicationRange::default()
            })
            .collect();
        directory.push(PublicationRange {
            role: 44,
            generation: 1,
            length_bytes: 8,
            ..PublicationRange::default()
        });
        let original: Vec<_> = layouts.values().map(|&layout| (layout, 0, 0, 24)).collect();
        let bind = |rows: &[(SemanticTensorLayout, u64, u64, usize)]| {
            model_content_ranges(&directory, &layouts, rows.iter().copied())
        };
        assert_eq!(bind(&original).unwrap(), vec![0, 1, 2, 3]);
        assert!(bind(&original[..3]).is_err());
        assert!(bind(&[]).is_err());
        let mut duplicate = original.clone();
        duplicate[3] = original[2];
        assert!(bind(&duplicate).is_err());
        let mut transient = original.clone();
        transient[0].0.role = 0;
        assert!(bind(&transient).is_err());
        let mut extra = original.clone();
        extra.push((layout(18, 2), 0, 0, 24));
        assert!(bind(&extra).is_err());
        let mut reordered = original.clone();
        reordered.reverse();
        assert_eq!(bind(&reordered).unwrap(), vec![3, 2, 1, 0]);
        let without_adapter: Vec<_> = directory
            .iter()
            .copied()
            .filter(|row| row.role != 19)
            .collect();
        let absent_adapter: Vec<_> = original
            .iter()
            .copied()
            .filter(|row| row.0.role != 19)
            .collect();
        assert!(
            model_content_ranges(&without_adapter, &layouts, absent_adapter.iter().copied())
                .is_ok()
        );
        assert!(
            model_content_ranges(&without_adapter, &layouts, original.iter().copied()).is_err()
        );
        assert!(model_content_ranges(&directory[..4], &layouts, original.iter().copied()).is_err());
    }

    #[test]
    fn model_content_binding_accepts_logical_equality_not_changed_shape_or_interval() {
        let expected = SemanticTensorLayout {
            role: 18,
            index: 0,
            scalar_type: 6,
            element_bytes: 4,
            rank: 2,
            logical_axis: 0,
            dimensions: [2, 3, 0, 0],
            strides_bytes: [12, 4, 0, 0],
        };
        let layouts = BTreeMap::from([((18, 0), expected)]);
        let directory = [
            PublicationRange {
                role: 18,
                generation: 1,
                length_bytes: 24,
                logical_begin: 5,
                logical_end: 7,
                ..PublicationRange::default()
            },
            PublicationRange {
                role: 44,
                generation: 1,
                length_bytes: 8,
                ..PublicationRange::default()
            },
        ];
        let bind = |layout, begin, end, bytes| {
            model_content_ranges(
                &directory,
                &layouts,
                std::iter::once((layout, begin, end, bytes)),
            )
        };
        let mut actual = expected;
        actual.strides_bytes = [4, 8, 0, 0];
        assert_eq!(bind(actual, 5, 7, 24).unwrap(), vec![0]);
        actual.strides_bytes = [32, 4, 0, 0];
        assert_eq!(bind(actual, 5, 7, 44).unwrap(), vec![0]);
        assert!(bind(actual, 5, 7, 24).is_err());
        assert!(bind(actual, 6, 8, 44).is_err());
        actual.strides_bytes = [4, 4, 0, 0];
        assert!(bind(actual, 5, 7, 16).is_err());
        actual = expected;
        actual.dimensions = [3, 2, 0, 0];
        actual.strides_bytes = [8, 4, 0, 0];
        assert!(bind(actual, 5, 8, 24).is_err());
        actual = expected;
        actual.scalar_type = 2;
        assert!(bind(actual, 5, 7, 24).is_err());
    }

    #[test]
    fn tensor_content_range_accepts_private_operands_without_publication_roles() {
        for (scalar_type, element_bytes, dtype) in [
            (
                9,
                8,
                crate::dlpack::DLDataType {
                    code: crate::dlpack::K_DLFLOAT,
                    bits: 64,
                    lanes: 1,
                },
            ),
            (
                7,
                8,
                crate::dlpack::DLDataType {
                    code: 0,
                    bits: 64,
                    lanes: 1,
                },
            ),
            (
                8,
                1,
                crate::dlpack::DLDataType {
                    code: 6,
                    bits: 8,
                    lanes: 1,
                },
            ),
            (
                6,
                4,
                crate::dlpack::DLDataType {
                    code: 2,
                    bits: 32,
                    lanes: 1,
                },
            ),
        ] {
            let mut layout = SemanticTensorLayout {
                role: 0,
                index: 0,
                scalar_type,
                element_bytes,
                rank: 2,
                logical_axis: u64::MAX,
                dimensions: [2, 3, 0, 0],
                strides_bytes: [element_bytes, 2 * element_bytes, 0, 0],
            };
            let metadata = TensorMetadata {
                device_type: 2,
                device_id: 0,
                dtype,
                shape: &[2, 3],
                strides: Some(&[1, 2]),
                data: 4096,
                byte_offset: 0,
            };
            let bytes = 6 * element_bytes as usize;
            assert_eq!(
                validate_tensor_metadata(&layout, &metadata, 0).unwrap(),
                (4096, bytes)
            );
            assert_eq!(tensor_content_range(&layout, 0, 0, bytes).unwrap().role, 0);
            assert!(SemanticStateRole::from_code(0).is_none());
            layout.role = 56;
            assert!(validate_tensor_metadata(&layout, &metadata, 0).is_err());
            assert!(tensor_content_range(&layout, 0, 0, bytes).is_err());
            layout.role = 0;
            layout.dimensions[0] = 0;
            assert_eq!(
                tensor_content_range(&layout, 0, 0, 0).unwrap().length_bytes,
                0
            );
        }
    }

    #[test]
    fn content_coordinates_keep_private_occurrences_in_original_roster_order() {
        assert!(validate_content_coordinates([(0, 0), (0, 1), (0, 2)].into_iter()).is_ok());
        assert!(validate_content_coordinates([(4, 1), (0, 1), (5, 1)].into_iter()).is_ok());
        for coordinates in [
            vec![(0, 1)],
            vec![(0, 0), (0, 0)],
            vec![(0, 0), (0, 2)],
            vec![(4, 0), (4, 0)],
            vec![(56, 0)],
        ] {
            assert!(validate_content_coordinates(coordinates.into_iter()).is_err());
        }
    }

    #[test]
    fn tensor_content_range_preserves_signed_tokens_and_boolean_masks() {
        for (scalar_type, element_bytes, dtype) in [
            (
                7,
                8,
                crate::dlpack::DLDataType {
                    code: 0,
                    bits: 64,
                    lanes: 1,
                },
            ),
            (
                8,
                1,
                crate::dlpack::DLDataType {
                    code: 6,
                    bits: 8,
                    lanes: 1,
                },
            ),
        ] {
            let layout = SemanticTensorLayout {
                role: 1,
                index: 0,
                scalar_type,
                element_bytes,
                rank: 2,
                logical_axis: 1,
                dimensions: [1, 3, 0, 0],
                strides_bytes: [3 * element_bytes, element_bytes, 0, 0],
            };
            let metadata = TensorMetadata {
                device_type: 2,
                device_id: 0,
                dtype,
                shape: &[1, 3],
                strides: Some(&[3, 1]),
                data: 4096,
                byte_offset: 0,
            };
            assert_eq!(
                validate_tensor_metadata(&layout, &metadata, 0).unwrap(),
                (4096, 3 * element_bytes as usize)
            );
            let range = tensor_content_range(&layout, 11, 14, 3 * element_bytes as usize).unwrap();
            assert_eq!(
                (
                    range.role,
                    range.index,
                    range.logical_begin,
                    range.logical_end
                ),
                (1, 0, 11, 14)
            );
            assert!(tensor_content_range(&layout, 11, 13, 3 * element_bytes as usize).is_err());
            let mut wrong = metadata;
            wrong.dtype.code = 1;
            assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
        }
    }

    #[test]
    fn tensor_content_range_checks_transposed_empty_and_exact_byte_extents() {
        let mut layout = SemanticTensorLayout {
            role: 4,
            index: 2,
            scalar_type: 6,
            element_bytes: 4,
            rank: 2,
            logical_axis: u64::MAX,
            dimensions: [2, 3, 0, 0],
            strides_bytes: [4, 8, 0, 0],
        };
        assert_eq!(
            tensor_content_range(&layout, 0, 0, 24)
                .unwrap()
                .length_bytes,
            24
        );
        assert!(tensor_content_range(&layout, 0, 1, 24).is_err());
        assert!(tensor_content_range(&layout, 0, 0, 23).is_err());
        assert!(tensor_content_range(&layout, 0, 0, 25).is_err());
        layout.logical_axis = 0;
        layout.dimensions[0] = 0;
        assert_eq!(
            tensor_content_range(&layout, 9, 9, 0).unwrap().length_bytes,
            0
        );
        assert!(tensor_content_range(&layout, 9, 8, 0).is_err());
    }

    fn publication_test_tensor(
        provider: &CudaKernelProvider,
        role: u64,
        value: f32,
    ) -> SemanticTensorInput {
        let bytes = value.to_le_bytes();
        let owner = allocate_publication::<u8>(provider, bytes.len()).unwrap();
        upload_publication(provider, &bytes, &owner).unwrap();
        let tensor = crate::dlpack::export_slice_managed_tensor(
            Arc::new(owner),
            provider.device().ordinal() as i32,
            crate::dlpack::DLDataType {
                code: 2,
                bits: 32,
                lanes: 1,
            },
            1,
            1,
        )
        .unwrap();
        SemanticTensorInput {
            layout: SemanticTensorLayout {
                role,
                index: 0,
                scalar_type: 6,
                element_bytes: 4,
                rank: 2,
                logical_axis: u64::MAX,
                dimensions: [1, 1, 0, 0],
                strides_bytes: [4, 4, 0, 0],
            },
            logical_begin: 0,
            logical_end: 0,
            tensor,
            native_allocation: None,
        }
    }

    pub(super) fn publication_test_session(
        provider: Arc<CudaKernelProvider>,
        domain: &ResidentExecutionDomain,
    ) -> SemanticTransitionSession {
        use crate::{SemanticArgument, SemanticPredicateRecord, SemanticTypedRecord};
        use xlog_core::{RelId, ScalarType, Schema};
        let mut graph = provider
            .allocate_semantic_hypergraph(
                domain,
                crate::SemanticHypergraphCapacities::try_new(4, 8, 8, 8).unwrap(),
            )
            .unwrap();
        let records = SemanticAdmissionRecords {
            predicates: vec![SemanticPredicateRecord {
                predicate: RelId(1),
                role: SemanticRecordRole::Statement,
                schema: Schema::new(vec![
                    ("left".into(), ScalarType::U32),
                    ("right".into(), ScalarType::U32),
                ])
                .with_sort_labels(vec!["bit".into(), "bit".into()])
                .unwrap(),
            }],
            records: [[1, 1], [0, 1]]
                .into_iter()
                .map(|values| SemanticTypedRecord {
                    predicate: RelId(1),
                    arguments: values.map(SemanticArgument::U32).to_vec(),
                    qualifiers: vec![],
                })
                .collect(),
            supports: vec![],
        };
        graph
            .admit_records(
                graph.empty_root(),
                records,
                SemanticAdmissionLimits {
                    max_records: 8,
                    max_terms: 32,
                    max_references: 8,
                    max_utf8_bytes: 256,
                },
            )
            .unwrap();
        let mut session = SemanticTransitionSession::from_hypergraph(graph).unwrap();
        session
            .bind_task_evaluation(task_binding_tests::task_spec([0, 1, 1], vec![]))
            .unwrap();
        session
    }

    fn publication_test_provider() -> (Arc<CudaKernelProvider>, ResidentExecutionDomain) {
        let provider = Arc::new(
            crate::CudaProviderBuilder::new(
                0,
                xlog_core::MemoryBudget::with_limit(512 * 1024 * 1024),
            )
            .with_stream_capacity(1)
            .build()
            .unwrap(),
        );
        let runtime = Arc::clone(provider.memory().runtime().unwrap());
        let stream_id = runtime.stream_pool().acquire().unwrap();
        let stream = runtime.stream_pool().resolve(stream_id).unwrap();
        let domain = provider
            .bind_resident_execution_domain(runtime, stream_id, stream)
            .unwrap();
        (provider, domain)
    }

    pub(super) fn publication_test_parent(provider: &CudaKernelProvider) -> SemanticParentBinding {
        let mut counts = [1u64; 55];
        counts[15] = 3;
        for role in [4, 5, 6, 7, 19, 20, 21, 22, 23, 24, 25, 51, 52, 53, 54] {
            counts[role - 1] = 0;
        }
        let mut records = Vec::new();
        let mut model_contract_layout = SemanticModelContractLayout::default();
        for role in 1..=55 {
            if is_tensor_role(role) || matches!(role, 1..=3 | 14..=16 | 30..=33 | 43 | 47 | 48 | 55)
            {
                continue;
            }
            let mut bytes = format!("application record {role}").into_bytes();
            if role == 44 {
                model_contract_layout = SemanticModelContractLayout {
                    schema_begin: 104,
                    schema_bytes: bytes.len() as u64,
                    schema_digest_offset: 0,
                    generation_offset: 32,
                    numerical_digest_offset: 40,
                    identity_offset: 72,
                };
                let mut record = vec![0; 104];
                record.extend_from_slice(&bytes);
                bytes = record;
            }
            records.push(SemanticStateRecord {
                role: SemanticStateRole::from_code(role).unwrap(),
                index: 0,
                capacity_bytes: 128,
                bytes,
            });
        }
        let slot = |token, logical_position, committed| SemanticTextSlot {
            token,
            logical_position,
            kind: 1,
            provenance: 1,
            valid: 1,
            committed,
            recomputed: 1,
            provenance_record: 0,
        };
        let mut source = [SemanticTextSlot::default(); 32];
        source[0] = slot(7, 0, 0);
        source[1] = slot(8, 1, 0);
        let model_owner = Arc::new(allocate_publication::<u8>(provider, 4).unwrap());
        upload_publication(provider, &18f32.to_le_bytes(), &model_owner).unwrap();
        let tensor = crate::dlpack::export_slice_managed_tensor(
            Arc::clone(&model_owner),
            provider.device().ordinal() as i32,
            crate::dlpack::DLDataType {
                code: 2,
                bits: 32,
                lanes: 1,
            },
            1,
            1,
        )
        .unwrap();
        let backing = crate::dlpack::export_slice_managed_tensor(
            Arc::clone(&model_owner),
            provider.device().ordinal() as i32,
            crate::dlpack::DLDataType {
                code: 1,
                bits: 8,
                lanes: 1,
            },
            1,
            4,
        )
        .unwrap();
        // SAFETY: this newly owned export has not been shared. Dropping its
        // singleton dimension preserves all four bytes and the original owner;
        // the retained shape allocation still owns the selected second entry.
        unsafe {
            let metadata = &mut (*backing.as_ptr()).dl_tensor;
            metadata.ndim = 1;
            metadata.shape = metadata.shape.add(1);
        }
        let model_layout = SemanticTensorLayout {
            role: 18,
            index: 0,
            scalar_type: 6,
            element_bytes: 4,
            rank: 2,
            logical_axis: u64::MAX,
            dimensions: [1, 1, 0, 0],
            strides_bytes: [4, 4, 0, 0],
        };
        let mut tensors = (8..=13)
            .map(|role| publication_test_tensor(provider, role, role as f32))
            .collect::<Vec<_>>();
        tensors.push(SemanticTensorInput {
            layout: model_layout,
            logical_begin: 0,
            logical_end: 0,
            tensor,
            native_allocation: None,
        });
        let mut parent = SemanticParentBinding {
            recovered_instance: None,
            source,
            prefix: vec![],
            ring_head: 2,
            provenance_records: 0,
            prefix_capacity: 64,
            feedback_capacity: 3,
            max_position: 262144,
            pad_token: 0,
            terminal_tokens: vec![100],
            final_intent_payload_bytes: 8,
            intent_effect: b"record result".to_vec(),
            intent_entry_capacity: 4,
            intent_payload_capacity_bytes: 256,
            acknowledgement_payload_capacity_bytes: 4096,
            model_generation: 1,
            policy_generation: 1,
            neural_generation: 1,
            cache_generation: 1,
            model_numerical_mode: b"native test numerical mode".to_vec(),
            model_contract_layout,
            authority_generation: 1,
            training_cursor: 0,
            training_rng: [1, 2, 3, 4],
            fuel: 8,
            rng: SemanticRngBinding {
                model_generation: 1,
                stream_serial: 5,
                family_id: 2,
                proposal: 0,
            },
            topology_identity: Identity256::from_bytes([4; 32]),
            table_identity: Identity256::from_bytes([5; 32]),
            role_counts: counts,
            records,
            tensors,
            model_memory: SemanticModelMemory {
                allocations: vec![SemanticTensorInput {
                    layout: SemanticTensorLayout {
                        role: 0,
                        index: 0,
                        scalar_type: 1,
                        element_bytes: 1,
                        rank: 1,
                        logical_axis: u64::MAX,
                        dimensions: [4, 0, 0, 0],
                        strides_bytes: [1, 0, 0, 0],
                    },
                    logical_begin: 0,
                    logical_end: 0,
                    tensor: backing,
                    native_allocation: None,
                }],
                storages: vec![SemanticModelStorage {
                    allocation: 0,
                    byte_offset: 0,
                    span_bytes: 4,
                }],
                views: vec![SemanticModelView {
                    role: 18,
                    index: 0,
                    storage: 0,
                    byte_offset: 0,
                }],
            },
            active_layouts: vec![],
        };
        parent
            .bind_initial_sources(
                &[SemanticObservedSource {
                    identity: "observed-input".into(),
                    tokens: vec![7, 8],
                    origin: b"complete observed fixture input".to_vec(),
                }],
                &(0..2)
                    .map(|position| SemanticSourceMapping {
                        source: "observed-input".into(),
                        offset: position,
                        logical_position: position,
                    })
                    .collect::<Vec<_>>(),
                b"current fixture authority",
                64,
            )
            .unwrap();
        parent
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn nonempty_initial_prefix_cannot_bind_without_its_prefill_stage() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        let mut parent = publication_test_parent(&provider);
        parent.prefix.push(SemanticTextSlot {
            token: 7,
            logical_position: 0,
            kind: 1,
            provenance: 1,
            valid: 1,
            committed: 1,
            ..SemanticTextSlot::default()
        });
        assert!(matches!(
            session.bind_parent(parent),
            Err(SemanticTransitionError::InvalidInput { .. })
        ));
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
    }

    fn publication_test_tensor_pair(
        provider: &CudaKernelProvider,
        layout: SemanticTensorLayout,
        bytes: &[u8],
    ) -> (SemanticTensorInput, SemanticTensorInput) {
        use xlog_core::{ScalarType, Schema};
        let owner = allocate_publication::<u8>(provider, bytes.len()).unwrap();
        upload_publication(provider, bytes, &owner).unwrap();
        let scalar = match layout.scalar_type {
            3 => ScalarType::U64,
            6 => ScalarType::F32,
            8 => ScalarType::Bool,
            _ => panic!("fixture tensor has an unsupported scalar type"),
        };
        let (original, captured) = if layout.rank == 1 {
            let buffer = provider
                .buffer_from_columns(
                    vec![crate::CudaColumn::Owned(owner)],
                    layout.dimensions[0],
                    Schema::new(vec![("value".into(), scalar)]),
                )
                .unwrap();
            let table = provider.to_dlpack_table(buffer);
            (table.column(0).unwrap(), table.column(0).unwrap())
        } else {
            assert_eq!(layout.rank, 2);
            let dtype = match scalar {
                ScalarType::U64 => crate::dlpack::DLDataType {
                    code: 1,
                    bits: 64,
                    lanes: 1,
                },
                ScalarType::F32 => crate::dlpack::DLDataType {
                    code: 2,
                    bits: 32,
                    lanes: 1,
                },
                _ => unreachable!("fixture matrices use floating point or unsigned integers"),
            };
            let owner = Arc::new(owner);
            let export = || {
                crate::dlpack::export_slice_managed_tensor(
                    Arc::clone(&owner),
                    provider.device().ordinal() as i32,
                    dtype,
                    layout.dimensions[0] as usize,
                    layout.dimensions[1] as usize,
                )
                .unwrap()
            };
            (export(), export())
        };
        let input = |tensor| SemanticTensorInput {
            layout,
            logical_begin: 0,
            logical_end: 0,
            tensor,
            native_allocation: None,
        };
        (input(original), input(captured))
    }

    pub(super) fn publication_test_continuation(
        session: &mut SemanticTransitionSession,
        old: &SemanticPublishedLease,
        provider: &CudaKernelProvider,
    ) -> (SemanticContinuationInput, SemanticTensorContentWitness) {
        publication_test_continuation_with_numerical_admissibility(session, old, provider, 1)
    }

    pub(super) fn publication_test_continuation_with_numerical_admissibility(
        session: &mut SemanticTransitionSession,
        old: &SemanticPublishedLease,
        provider: &CudaKernelProvider,
        numerical_admissibility: u8,
    ) -> (SemanticContinuationInput, SemanticTensorContentWitness) {
        assert!(numerical_admissibility <= 1);
        let contract = session.publication.as_ref().unwrap().contract_value;
        let feedback = session
            .read_published_record_bytes(old, SemanticStateRole::RawFeedback)
            .unwrap();
        assert_eq!(
            feedback.len(),
            contract.feedback_capacity as usize * size_of::<RawFeedbackRecord>()
        );
        let mut filled: Vec<_> = old
            .source
            .iter()
            .enumerate()
            .filter(|(_, slot)| slot.valid == 1 && slot.kind == 1)
            .collect();
        let mut masks: Vec<_> = old
            .source
            .iter()
            .enumerate()
            .filter(|(_, slot)| slot.valid == 1 && slot.kind == 2)
            .collect();
        filled.sort_by_key(|(_, slot)| slot.logical_position);
        masks.sort_by_key(|(_, slot)| slot.logical_position);
        let mut text_rows = vec![0u64; 32 * 2];
        for (row, &(slot, source)) in masks.iter().enumerate() {
            text_rows[row * 2] = slot as u64;
            text_rows[row * 2 + 1] = source.logical_position;
        }
        let capacity = 32 + contract.feedback_capacity;
        let mut active_rows = vec![0u64; capacity as usize * 4];
        let mut active_count = 0u64;
        let mut append = |physical, slot, position, kind| {
            let offset = active_count as usize * 4;
            active_rows[offset..offset + 4].copy_from_slice(&[physical, slot, position, kind]);
            active_count += 1;
        };
        for (physical, &(slot, source)) in filled.iter().enumerate() {
            append(physical as u64, slot as u64, source.logical_position, 1);
        }
        for (slot, record) in feedback
            .as_chunks::<{ size_of::<RawFeedbackRecord>() }>()
            .0
            .iter()
            .enumerate()
        {
            let valid = u64::from_ne_bytes(record[..8].try_into().unwrap());
            assert!(valid <= 1);
            if valid == 1 {
                append(
                    (filled.len() + slot) as u64,
                    32 + slot as u64,
                    contract.prefix_capacity + 32 + slot as u64,
                    3,
                );
            }
        }
        for (offset, &(slot, source)) in masks.iter().enumerate() {
            append(
                filled.len() as u64 + contract.feedback_capacity + offset as u64,
                slot as u64,
                source.logical_position,
                2,
            );
        }
        let mut tensors = Vec::new();
        let mut capture = Vec::new();
        for role in 8..=13 {
            let layout = SemanticTensorLayout {
                role,
                index: 0,
                scalar_type: 6,
                element_bytes: 4,
                rank: 2,
                logical_axis: u64::MAX,
                dimensions: [1, 1, 0, 0],
                strides_bytes: [4, 4, 0, 0],
            };
            let (original, witnessed) =
                publication_test_tensor_pair(provider, layout, &(role as f32 + 1.0).to_ne_bytes());
            tensors.push(original);
            capture.push(witnessed);
        }
        let service_bytes = [
            publication_abi_bytes(&text_rows),
            publication_abi_bytes(&[masks.len() as u64]),
            vec![0u8; 32],
            publication_abi_bytes(&active_rows),
            publication_abi_bytes(&[active_count]),
            vec![numerical_admissibility],
        ];
        let layouts = continuation_service_layouts(tensors.len(), capacity, None).unwrap();
        let mut services = Vec::new();
        for (layout, bytes) in layouts.into_iter().zip(service_bytes) {
            let (original, witnessed) = publication_test_tensor_pair(provider, layout, &bytes);
            services.push(original.tensor);
            capture.push(witnessed);
        }
        let witness = session.capture_tensor_content(old, capture, 1).unwrap();
        let [text_rows, text_row_count, selected_text, active_rows, active_row_count, numerical_admissibility]:
            [DlpackManagedTensor; 6] = services.try_into().ok().unwrap();
        (
            SemanticContinuationInput {
                tensors,
                authority_decisions: b"current fixture continuation".to_vec(),
                text_rows,
                text_row_count,
                selected_text,
                active_rows,
                active_row_count,
                numerical_admissibility,
                numerical_blocks: None,
                model_schema_digest: None,
                model_identity: None,
            },
            witness,
        )
    }

    fn publication_test_recompute(
        session: &mut SemanticTransitionSession,
        old: &SemanticPublishedLease,
        provider: &crate::CudaKernelProvider,
    ) {
        session
            .admit_transition(old, SemanticTransitionKind::Recompute)
            .unwrap();
        let (continuation, witness) = publication_test_continuation(session, old, provider);
        session
            .bind_continuation(old, continuation, &witness, 1)
            .unwrap();
        drop(witness);
        session.capture().unwrap();
        session.launch().unwrap();
        session.observe(0).unwrap();
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn publication_material_native_restore_preserves_acquired_prefix_feedback_and_history() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut old = session.acquire().unwrap();
        let old_prefix = session
            .read_published_record_bytes(&old, SemanticStateRole::PrefixSource)
            .unwrap();
        let old_mode = session.published_model_numerical_mode(&old).unwrap();
        assert_eq!(old_mode, b"native test numerical mode");
        let old_material = session.published_state_material(&old).unwrap();
        let (_, alias) = session.published_prefix(&old, 1).unwrap();
        publication_test_recompute(&mut session, &old, &provider);
        let mut current = session.acquire().unwrap();
        assert_eq!(current.header.prefix_extent, old.header.prefix_extent + 1);
        assert_eq!(
            session
                .read_published_record_bytes(&old, SemanticStateRole::PrefixSource)
                .unwrap(),
            old_prefix
        );
        assert_eq!(
            session.published_state_material(&old).unwrap(),
            old_material
        );
        assert!(session.release(&mut old, &[1]).is_err());
        drop(alias);
        session.release(&mut old, &[1]).unwrap();
        let bytes = session.published_state_material(&current).unwrap();
        let original = PublicationMaterial::decode(&bytes).unwrap();
        session.release(&mut current, &[]).unwrap();
        drop(session);
        let mut restored = publication_test_session(Arc::clone(&provider), &domain);
        let identity = restored.restore_state_material(&bytes).unwrap();
        assert_ne!(identity.instance, original.bank.header.instance);
        assert_eq!(identity.logical_digest, original.bank.header.logical_digest);
        assert_eq!(identity.state_digest, original.bank.header.state_digest);
        let mut lease = restored.acquire().unwrap();
        assert_eq!(
            restored.published_model_numerical_mode(&lease).unwrap(),
            old_mode
        );
        let reread =
            PublicationMaterial::decode(&restored.published_state_material(&lease).unwrap())
                .unwrap();
        for role in [1, 2, 14, 15, 27, 28, 30, 31, 32, 33, 43] {
            assert_eq!(
                reread
                    .ranges
                    .iter()
                    .find(|item| item.range.role == role)
                    .unwrap()
                    .bytes,
                original
                    .ranges
                    .iter()
                    .find(|item| item.range.role == role)
                    .unwrap()
                    .bytes,
                "role {role}"
            );
        }
        assert_eq!(reread.graph, original.graph);
        restored.release(&mut lease, &[]).unwrap();
        drop(restored);
        provider.memory().reap_pending_deallocations().unwrap();
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn publication_material_runtime_reader_rejects_completed_layout_alias_writes() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut lease = session.acquire().unwrap();
        let mode = session.published_model_numerical_mode(&lease).unwrap();
        let original = session
            .read_published_record_bytes(&lease, SemanticStateRole::TensorLayout)
            .unwrap();
        let alias = session
            .published_record(&lease, SemanticStateRole::TensorLayout, 0, 1)
            .unwrap();
        // SAFETY: the live managed alias retains its descriptor and the exact
        // published allocation for the duration of both consumer writes.
        let tensor = unsafe { &(*alias.as_ptr()).dl_tensor };
        let pointer = tensor.data as usize as u64 + tensor.byte_offset;
        // Mutate a layout value and then only the active-computed marker. The
        // latter leaves cold layouts intact, so the original seal is necessary.
        for offset in [
            size_of::<TensorLayoutTableHeader>() + 2 * size_of::<u64>(),
            2 * size_of::<u64>(),
        ] {
            assert!(offset < original.len());
            // SAFETY: one in-bounds byte of this retained alias, submitted on
            // its registered legacy stream; no further writer is submitted
            // until the getter has completed and checked that stream prefix.
            assert_eq!(
                unsafe {
                    sys::cuMemsetD8Async(
                        pointer + offset as u64,
                        original[offset] ^ 1,
                        1,
                        std::ptr::null_mut(),
                    )
                },
                sys::cudaError_enum::CUDA_SUCCESS
            );
            assert!(matches!(
                session.published_model_numerical_mode(&lease),
                Err(SemanticTransitionError::ObservationMismatch)
            ));
            // SAFETY: restore this test's byte on the same retained alias and
            // registered stream so ordinary retirement sees the original state.
            assert_eq!(
                unsafe {
                    sys::cuMemsetD8Async(
                        pointer + offset as u64,
                        original[offset],
                        1,
                        std::ptr::null_mut(),
                    )
                },
                sys::cudaError_enum::CUDA_SUCCESS
            );
            assert_eq!(
                session.published_model_numerical_mode(&lease).unwrap(),
                mode
            );
        }
        drop(alias);
        session.release(&mut lease, &[1]).unwrap();
        drop(session);
        provider.memory().reap_pending_deallocations().unwrap();
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run; fatal cases use fresh processes"]
    fn replay_boundaries_reject_mutated_shared_predecessor_weights() {
        const CHILD_KIND: &str = "XLOG_REPLAY_CONTENT_TEST_CHILD";
        const COMPLETED: &str =
            "shared replay content mutation produced a fatal CUDA completion error";
        let Some(kind) = std::env::var_os(CHILD_KIND) else {
            let qualified = concat!(
                module_path!(),
                "::replay_boundaries_reject_mutated_shared_predecessor_weights"
            );
            let test_name = qualified.split_once("::").unwrap().1;
            for kind in ["verify", "evidence", "provenance"] {
                let output = std::process::Command::new(std::env::current_exe().unwrap())
                    .args([
                        "--exact",
                        test_name,
                        "--ignored",
                        "--nocapture",
                        "--test-threads=1",
                    ])
                    .env(CHILD_KIND, kind)
                    .output()
                    .unwrap();
                assert!(
                    output.status.success(),
                    "{kind} child did not verify a CUDA trap:\n{}\n{}",
                    String::from_utf8_lossy(&output.stdout),
                    String::from_utf8_lossy(&output.stderr)
                );
                assert!(
                    String::from_utf8_lossy(&output.stdout).contains(COMPLETED),
                    "{kind} child did not reach the typed CUDA completion check"
                );
            }
            return;
        };
        assert!(kind == "verify" || kind == "evidence" || kind == "provenance");
        let (provider, domain) = publication_test_provider();
        let mut original = publication_test_session(Arc::clone(&provider), &domain);
        original
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut old = original.acquire().unwrap();
        let predecessor_bytes = original.published_state_material(&old).unwrap();
        publication_test_recompute(&mut original, &old, &provider);
        let mut current = original.acquire().unwrap();
        let evidence = original.published_replay_evidence(&old, &current).unwrap();
        assert!(
            original.release_events.is_empty(),
            "completed export events must not wait for reader release"
        );
        let material = SemanticReplayMaterial::decode(
            &predecessor_bytes,
            &evidence,
            old.identity.logical_digest,
            current.identity.logical_digest,
        )
        .unwrap();
        original.release(&mut old, &[1]).unwrap();
        original.release(&mut current, &[1]).unwrap();
        drop(original);

        let mut replay = publication_test_session(Arc::clone(&provider), &domain);
        replay.restore_replay_material(&material).unwrap();
        let predecessor = replay.acquire().unwrap();
        publication_test_recompute(&mut replay, &predecessor, &provider);
        let successor = replay.acquire().unwrap();
        let alias = replay
            .published_tensor(&predecessor, SemanticStateRole::SlowWeights, 0, 1)
            .unwrap();
        let successor_alias = replay
            .published_tensor(&successor, SemanticStateRole::SlowWeights, 0, 1)
            .unwrap();
        // SAFETY: each managed export retains its own actual acquired reader and
        // valid DLPack descriptor; the pointers prove these banks share weights.
        let tensor = unsafe { &(*alias.as_ptr()).dl_tensor };
        let successor_tensor = unsafe { &(*successor_alias.as_ptr()).dl_tensor };
        assert_eq!(tensor.byte_offset, 0);
        assert_eq!(tensor.data, successor_tensor.data);
        let pointer = tensor.data as usize as u64;
        drop(successor_alias);
        replay
            .verify_replay_publication(&material, &predecessor, &successor)
            .unwrap();
        replay
            .published_replay_evidence(&predecessor, &successor)
            .unwrap();
        replay
            .published_replay_provenance(&predecessor, &successor)
            .unwrap();
        // SAFETY: the fixture's live alias retains four FP32 bytes, and the
        // external write uses the actual registered legacy consumer stream.
        assert_eq!(
            unsafe { sys::cuMemsetD8Async(pointer, 0, 4, std::ptr::null_mut()) },
            sys::cudaError_enum::CUDA_SUCCESS
        );
        if kind == "verify" {
            drop(alias);
            replay.quiesce_published_reader(&predecessor, &[1]).unwrap();
            assert!(replay
                .verify_replay_publication(&material, &predecessor, &successor)
                .is_err());
        } else if kind == "evidence" {
            assert!(replay
                .published_replay_evidence(&predecessor, &successor)
                .is_err());
        } else {
            assert!(replay
                .published_replay_provenance(&predecessor, &successor)
                .is_err());
        }
        // SAFETY: only this disposable child's context has been poisoned. A
        // typed fatal CUDA error, not a Rust panic, establishes guard refusal.
        let completion = unsafe { sys::cuStreamSynchronize(std::ptr::null_mut()) };
        assert!(
            matches!(
                completion,
                sys::cudaError_enum::CUDA_ERROR_ILLEGAL_INSTRUCTION
                    | sys::cudaError_enum::CUDA_ERROR_LAUNCH_FAILED
            ),
            "unexpected CUDA completion: {completion:?}"
        );
        println!("{COMPLETED}");
        std::io::Write::flush(&mut std::io::stdout()).unwrap();
        std::process::exit(0);
    }

    fn publication_test_alias(
        session: &mut SemanticTransitionSession,
        lease: &SemanticPublishedLease,
        role: SemanticStateRole,
        consumer_stream: u64,
    ) -> SemanticTensorInput {
        let layout = session.publication.as_ref().unwrap().layouts[&(role as u64, 0)];
        let range = *lease
            .directory
            .iter()
            .find(|range| range.role == role as u64 && range.index == 0)
            .unwrap();
        let (native_allocation, backing) = session
            .published_tensor_allocation(lease, role, 0, consumer_stream)
            .unwrap();
        drop(backing);
        SemanticTensorInput {
            layout,
            logical_begin: range.logical_begin,
            logical_end: range.logical_end,
            tensor: session
                .published_tensor(lease, role, 0, consumer_stream)
                .unwrap(),
            native_allocation: Some(native_allocation),
        }
    }

    struct ContentTestExport {
        managed: crate::dlpack::DLManagedTensor,
        _owner: DlpackManagedTensor,
        shape: [i64; 2],
        strides: [i64; 2],
    }

    unsafe extern "C" fn delete_content_test_export(managed: *mut crate::dlpack::DLManagedTensor) {
        if managed.is_null() {
            return;
        }
        // SAFETY: content_test_export installs this sole Box owner and deleter;
        // its canonical managed backing owns the real allocation until drop.
        let owner = unsafe { (*managed).manager_ctx.cast::<ContentTestExport>() };
        if !owner.is_null() {
            drop(unsafe { Box::from_raw(owner) });
        }
    }

    fn content_test_export(
        owner: Arc<TrackedCudaSlice<u8>>,
        device_id: i32,
        dtype: crate::dlpack::DLDataType,
        layout: SemanticTensorLayout,
        logical_interval: (u64, u64),
    ) -> SemanticTensorInput {
        assert_eq!(layout.rank, 2);
        let shape = [
            i64::try_from(layout.dimensions[0]).unwrap(),
            i64::try_from(layout.dimensions[1]).unwrap(),
        ];
        let strides = [
            i64::try_from(layout.strides_bytes[0] / layout.element_bytes).unwrap(),
            i64::try_from(layout.strides_bytes[1] / layout.element_bytes).unwrap(),
        ];
        let backing = crate::dlpack::export_slice_managed_tensor(
            owner,
            device_id,
            dtype,
            usize::try_from(shape[0]).unwrap(),
            usize::try_from(shape[1]).unwrap(),
        )
        .unwrap();
        // SAFETY: the canonical export owns valid, producer-ready metadata and
        // storage. The test producer supplies a genuine view of those bytes,
        // retaining both explicit strides and the original owner in one Box.
        let source = unsafe { &(*backing.as_ptr()).dl_tensor };
        let mut export = Box::new(ContentTestExport {
            managed: crate::dlpack::DLManagedTensor {
                dl_tensor: crate::dlpack::DLTensor {
                    data: source.data,
                    device: source.device,
                    ndim: 2,
                    dtype: source.dtype,
                    shape: std::ptr::null_mut(),
                    strides: std::ptr::null_mut(),
                    byte_offset: source.byte_offset,
                },
                manager_ctx: std::ptr::null_mut(),
                deleter: Some(delete_content_test_export),
            },
            _owner: backing,
            shape,
            strides,
        });
        export.managed.dl_tensor.shape = export.shape.as_mut_ptr();
        export.managed.dl_tensor.strides = export.strides.as_mut_ptr();
        let owner = Box::into_raw(export);
        // SAFETY: the stable Box retains the actual managed CUDA allocation
        // and both metadata arrays; the assigned deleter consumes that Box once.
        let tensor = unsafe {
            (*owner).managed.manager_ctx = owner.cast();
            DlpackManagedTensor::from_raw(&mut (*owner).managed)
        };
        SemanticTensorInput {
            layout,
            logical_begin: logical_interval.0,
            logical_end: logical_interval.1,
            tensor,
            native_allocation: None,
        }
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn native_feedback_alias_capture_reuses_original_producer_seals() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut lease = session.acquire().unwrap();
        session
            .admit_transition(&lease, SemanticTransitionKind::Proposal)
            .unwrap();
        let feedback = session.published_feedback(&lease, 1).unwrap();
        let layouts = session.steps[&lease.token].feedback[0]
            .content
            .tensors
            .iter()
            .map(|tensor| tensor.layout)
            .collect::<Vec<_>>();
        let inputs = feedback
            .into_dlpack()
            .into_iter()
            .zip(layouts.iter().copied())
            .map(|(tensor, layout)| SemanticTensorInput {
                tensor,
                layout,
                logical_begin: 0,
                logical_end: 0,
                native_allocation: None,
            })
            .collect();
        let mut other = session.acquire().unwrap();
        assert!(
            session.capture_tensor_content(&other, inputs, 1).is_err(),
            "a second reader must not reseal the first reader's native outputs"
        );
        session.release(&mut other, &[1]).unwrap();
        let feedback = session.published_feedback(&lease, 1).unwrap();
        let inputs = feedback
            .into_dlpack()
            .into_iter()
            .zip(layouts)
            .map(|(tensor, layout)| SemanticTensorInput {
                tensor,
                layout,
                logical_begin: 0,
                logical_end: 0,
                native_allocation: None,
            })
            .collect();
        let witness = session.capture_tensor_content(&lease, inputs, 1).unwrap();
        let reader = &session.steps[&lease.token];
        let TensorContentSeals::Captured(original) = &reader.feedback[1].content.seals else {
            panic!("native producer seals");
        };
        let TensorContentSeals::Captured(consumer) = &reader.content[witness.index].seals else {
            panic!("original alias seals");
        };
        assert_eq!(original.len(), 6);
        for (original, consumer) in original.iter().zip(consumer) {
            let CapturedTensorDigest::Tensor {
                cells: original, ..
            } = original
            else {
                panic!("feedback producer digest");
            };
            let CapturedTensorDigest::Tensor {
                cells: consumer,
                producer_sealed,
                ..
            } = consumer
            else {
                panic!("feedback alias digest");
            };
            assert!(
                Arc::ptr_eq(original, consumer),
                "alias capture must not allocate a replacement digest"
            );
            assert!(
                *producer_sealed,
                "alias capture must verify, never overwrite the producer seal"
            );
        }
        drop(witness);
        session.release(&mut lease, &[1]).unwrap();
        drop(session);
        provider.memory().reap_pending_deallocations().unwrap();
        assert_eq!(provider.memory().allocated_bytes(), 0);
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn retained_model_content_survives_reader_retirement_and_bank_reuse() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut lease = session.acquire().unwrap();
        let identity = session.published_identity(&lease).unwrap();
        let layout = session.publication.as_ref().unwrap().layouts[&(18, 0)];
        let live = Arc::new(allocate_publication::<u8>(&provider, 4).unwrap());
        upload_publication(&provider, &18.0f32.to_le_bytes(), &live).unwrap();
        let producer = || {
            content_test_export(
                Arc::clone(&live),
                provider.device().ordinal() as i32,
                crate::dlpack::DLDataType {
                    code: 2,
                    bits: 32,
                    lanes: 1,
                },
                layout,
                (0, 0),
            )
        };
        let witness = session
            .bind_model_content(&lease, vec![producer()], 1)
            .unwrap();
        session
            .admit_transition(&lease, SemanticTransitionKind::Recompute)
            .unwrap();
        let feedback = session.published_feedback(&lease, 1).unwrap();
        assert!(session.release_published_reader(&mut lease, &[1]).is_err());
        let (continuation, continuation_witness) =
            publication_test_continuation(&mut session, &lease, &provider);
        session
            .bind_continuation(&lease, continuation, &continuation_witness, 1)
            .unwrap();
        drop(continuation_witness);
        session.capture().unwrap();
        session.launch().unwrap();
        session.observe(0).unwrap();
        let (_, bank_alias) = session.published_prefix(&lease, 1).unwrap();
        assert!(session.release_published_reader(&mut lease, &[1]).is_err());
        assert!(lease.is_active());
        drop(bank_alias);
        session.release_published_reader(&mut lease, &[1]).unwrap();
        assert!(!lease.is_active());
        assert_eq!(session.retained_step_identity(&lease).unwrap(), identity);
        assert!(session.published_source(&lease, 1).is_err());
        assert!(session.quiesce_published_reader(&lease, &[1]).is_err());
        assert!(session.release(&mut lease, &[1]).is_err());
        for _ in 0..2 {
            let mut current = session.acquire().unwrap();
            publication_test_recompute(&mut session, &current, &provider);
            session.release(&mut current, &[1]).unwrap();
        }
        let mut reused = session.acquire().unwrap();
        assert_eq!((reused.identity.word >> 1) - (identity.word >> 1), 3);
        session.release(&mut reused, &[]).unwrap();
        let before = session.host_io_stats();
        session
            .verify_tensor_content(&lease, &witness, vec![producer()], 1)
            .unwrap();
        assert_eq!(session.host_io_stats(), before);
        drop(witness);
        assert!(
            session.release(&mut lease, &[1]).is_err(),
            "original feedback exports retain their step"
        );
        drop(feedback);
        session.release(&mut lease, &[1]).unwrap();
        assert!(session.retained_step_identity(&lease).is_err());
        drop(live);
        drop(session);
        provider.memory().reap_pending_deallocations().unwrap();
        assert_eq!(provider.memory().allocated_bytes(), 0);
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn model_content_binding_uses_original_seals_and_retires_each_reader() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        for _ in 0..2 {
            let mut lease = session.acquire().unwrap();
            let layout = session.publication.as_ref().unwrap().layouts[&(18, 0)];
            let live = Arc::new(allocate_publication::<u8>(&provider, 4).unwrap());
            upload_publication(&provider, &18.0f32.to_le_bytes(), &live).unwrap();
            let producer = || {
                content_test_export(
                    Arc::clone(&live),
                    provider.device().ordinal() as i32,
                    crate::dlpack::DLDataType {
                        code: 2,
                        bits: 32,
                        lanes: 1,
                    },
                    layout,
                    (0, 0),
                )
            };
            let original = producer();
            let same = producer();
            let substituted =
                publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
            let before = session.host_io_stats();
            let witness = session
                .bind_model_content(&lease, vec![original], 1)
                .unwrap();
            assert!(
                matches!(
                    session.steps[&lease.token].content[witness.index].seals,
                    TensorContentSeals::Model(_)
                ),
                "model binding must not capture a replacement baseline"
            );
            session
                .verify_tensor_content(&lease, &witness, vec![same], 1)
                .unwrap();
            assert_eq!(session.host_io_stats(), before);
            assert!(
                session
                    .verify_tensor_content(&lease, &witness, vec![substituted], 1)
                    .is_err(),
                "equal publication bytes cannot replace this invocation's original live storage"
            );
            assert!(session.release(&mut lease, &[1]).is_err());
            drop(witness);
            session.release(&mut lease, &[1]).unwrap();
            assert!(
                session.readers.is_empty(),
                "the first reader is not a permanent model baseline"
            );
        }
        drop(session);
        provider.memory().reap_pending_deallocations().unwrap();
        assert_eq!(provider.memory().allocated_bytes(), 0);
        assert_eq!(provider.memory().deallocation_failure_bytes(), 0);
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn publication_content_guards_preserve_zero_transfer_and_release_parent_alias_witnesses() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut original = session.acquire().unwrap();
        let material = session.published_state_material(&original).unwrap();
        session.release(&mut original, &[]).unwrap();
        drop(session);
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session.restore_state_material(&material).unwrap();
        let mut lease = session.acquire().unwrap();
        let before_exports = session.host_io_stats();
        let sealed_prefix = *lease
            .directory
            .iter()
            .find(|range| range.role == 1)
            .unwrap();
        let (_, prefix) = session.published_prefix(&lease, 1).unwrap();
        let source = session.published_source(&lease, 1).unwrap();
        let context = session.published_model_context(&lease, 1).unwrap();
        assert!(matches!(
            session.published_model_context(&lease, 2),
            Err(SemanticTransitionError::InvalidInput { .. })
        ));
        let outside_alias = session
            .published_tensor(&lease, SemanticStateRole::SlowWeights, 0, 1)
            .unwrap();
        assert_eq!(
            session.host_io_stats(),
            before_exports,
            "native capacity exports must not copy metadata or wait on the host"
        );
        // SAFETY: the genuine managed export retains its complete descriptor
        // and shape array until prefix is dropped below. No device bytes read.
        let prefix_tensor = unsafe { &(*prefix.as_ptr()).dl_tensor };
        assert_eq!(prefix_tensor.ndim, 2);
        assert_eq!(
            unsafe { std::slice::from_raw_parts(prefix_tensor.shape, 2) },
            [64, 8]
        );
        assert_eq!(
            (prefix_tensor.dtype.code, prefix_tensor.dtype.bits),
            (1, 64)
        );
        let storage = session.publication.as_ref().unwrap();
        let bank = storage.banks[(lease.identity.word & 1) as usize].device_ptr_value();
        for (tensor, field) in [
            (&source, PublicationBankField::Source),
            (&context.source, PublicationBankField::Source),
            (&context.prefix.1, PublicationBankField::PrefixExtent),
            (&context.ring_head, PublicationBankField::RingHead),
        ] {
            let (range, shape, strides) = field.layout();
            // SAFETY: every descriptor and metadata array belongs to the live
            // genuine managed export retained above; device bytes are not read.
            let tensor = unsafe { &(*tensor.as_ptr()).dl_tensor };
            assert_eq!(
                tensor.data as usize as u64 + tensor.byte_offset,
                bank + range.start as u64
            );
            assert_eq!((tensor.dtype.code, tensor.dtype.bits), (1, 64));
            assert_eq!(tensor.ndim as usize, shape.len());
            assert_eq!(
                unsafe { std::slice::from_raw_parts(tensor.shape, shape.len()) },
                shape
            );
            assert_eq!(
                unsafe { std::slice::from_raw_parts(tensor.strides, strides.len()) },
                strides
            );
        }
        let prefix_range = lease
            .directory
            .iter()
            .find(|range| range.role == 3)
            .unwrap();
        let identity_tensor = unsafe { &(*context.prefix.0.as_ptr()).dl_tensor };
        assert_eq!(
            identity_tensor.data as usize as u64 + identity_tensor.byte_offset,
            storage.allocations[prefix_range.storage_slot as usize].device_ptr_value()
                + prefix_range.offset_bytes
        );
        assert_eq!(
            (
                identity_tensor.ndim,
                identity_tensor.dtype.code,
                identity_tensor.dtype.bits
            ),
            (1, 1, 8)
        );
        assert_eq!(unsafe { *identity_tensor.shape }, 32);
        assert_eq!(context.parent, lease.identity);
        assert_eq!(context.descriptor_digest, lease.header.descriptor_digest);
        let after_prefix = lease
            .directory
            .iter()
            .find(|range| range.role == 1)
            .unwrap();
        assert_eq!(
            (
                after_prefix.logical_begin,
                after_prefix.logical_end,
                after_prefix.length_bytes,
                after_prefix.digest
            ),
            (
                sealed_prefix.logical_begin,
                sealed_prefix.logical_end,
                sealed_prefix.length_bytes,
                sealed_prefix.digest
            )
        );
        drop(prefix);
        drop(source);
        drop(context);
        // Generic producer fixture setup is cold; the original content-guard
        // measurement below starts after those fixture uploads and handoffs.
        let mut captured = vec![publication_test_alias(
            &mut session,
            &lease,
            SemanticStateRole::SlowWeights,
            1,
        )];
        let mut verified = vec![publication_test_alias(
            &mut session,
            &lease,
            SemanticStateRole::SlowWeights,
            1,
        )];
        let mut owners = Vec::new();
        let cases = [
            (
                SemanticTensorLayout {
                    role: 0,
                    index: 0,
                    scalar_type: 7,
                    element_bytes: 8,
                    rank: 2,
                    logical_axis: u64::MAX,
                    dimensions: [1, 3, 0, 0],
                    strides_bytes: [24, 8, 0, 0],
                },
                crate::dlpack::DLDataType {
                    code: crate::dlpack::K_DLINT,
                    bits: 64,
                    lanes: 1,
                },
                [i64::MIN, -7, i64::MAX]
                    .into_iter()
                    .flat_map(i64::to_le_bytes)
                    .collect::<Vec<_>>(),
                (0, 0),
            ),
            (
                SemanticTensorLayout {
                    role: 0,
                    index: 0,
                    scalar_type: 8,
                    element_bytes: 1,
                    rank: 2,
                    logical_axis: u64::MAX,
                    dimensions: [1, 3, 0, 0],
                    strides_bytes: [3, 1, 0, 0],
                },
                crate::dlpack::DLDataType {
                    code: crate::dlpack::K_DLBOOL,
                    bits: 8,
                    lanes: 1,
                },
                vec![0, 1, 1],
                (0, 0),
            ),
            (
                SemanticTensorLayout {
                    role: 0,
                    index: 0,
                    scalar_type: 6,
                    element_bytes: 4,
                    rank: 2,
                    logical_axis: u64::MAX,
                    dimensions: [2, 3, 0, 0],
                    strides_bytes: [4, 8, 0, 0],
                },
                crate::dlpack::DLDataType {
                    code: crate::dlpack::K_DLFLOAT,
                    bits: 32,
                    lanes: 1,
                },
                [1.0f32, 4.0, 2.0, 5.0, 3.0, 6.0]
                    .into_iter()
                    .flat_map(f32::to_le_bytes)
                    .collect(),
                (0, 0),
            ),
            (
                SemanticTensorLayout {
                    role: 0,
                    index: 0,
                    scalar_type: 6,
                    element_bytes: 4,
                    rank: 2,
                    logical_axis: u64::MAX,
                    dimensions: [0, 3, 0, 0],
                    strides_bytes: [12, 4, 0, 0],
                },
                crate::dlpack::DLDataType {
                    code: crate::dlpack::K_DLFLOAT,
                    bits: 32,
                    lanes: 1,
                },
                Vec::new(),
                (0, 0),
            ),
        ];
        for (mut layout, dtype, bytes, interval) in cases {
            layout.index = captured.len() as u64;
            assert_eq!(tensor_layout_bytes(&layout).unwrap(), bytes.len());
            let owner = Arc::new(allocate_publication::<u8>(&provider, bytes.len()).unwrap());
            if !bytes.is_empty() {
                upload_publication(&provider, &bytes, &owner).unwrap();
            }
            let device = provider.device().ordinal() as i32;
            let rejected = content_test_export(Arc::clone(&owner), device, dtype, layout, interval);
            let mut invalid_parent = publication_test_parent(&provider);
            invalid_parent.tensors.push(rejected);
            let mut admission = publication_test_session(Arc::clone(&provider), &domain);
            assert!(matches!(admission.bind_parent(invalid_parent),
                Err(SemanticTransitionError::InvalidInput { detail })
                    if detail == "initial parent tensor role is duplicate, uncomputed-active, or outside its model roster"));
            drop(admission);
            captured.push(content_test_export(
                Arc::clone(&owner),
                device,
                dtype,
                layout,
                interval,
            ));
            verified.push(content_test_export(
                Arc::clone(&owner),
                device,
                dtype,
                layout,
                interval,
            ));
            owners.push(owner);
        }
        let before = session.host_io_stats();
        session
            .guard_published_content(
                &lease,
                &[
                    (SemanticStateRole::PrefixSource, 0),
                    (SemanticStateRole::SlowWeights, 0),
                ],
                1,
            )
            .unwrap();
        let witness = session.capture_tensor_content(&lease, captured, 1).unwrap();
        session
            .verify_tensor_content(&lease, &witness, verified, 1)
            .unwrap();
        assert_eq!(
            session.host_io_stats(),
            before,
            "content guards must add no host transfers, metadata readback or session stream waits"
        );
        // SAFETY: protocol stream one is this context's legacy default stream;
        // native guard events order its consumers. This is terminal test work.
        assert_eq!(
            unsafe { sys::cuStreamSynchronize(std::ptr::null_mut()) },
            sys::cudaError_enum::CUDA_SUCCESS
        );
        assert!(
            session.release(&mut lease, &[1]).is_err(),
            "a live witness retains its reader"
        );
        assert!(session.quiesce_published_reader(&lease, &[1]).is_err());
        drop(witness);
        assert!(
            session.release(&mut lease, &[1]).is_err(),
            "an external alias still retains its reader"
        );
        assert!(session.quiesce_published_reader(&lease, &[1]).is_err());
        drop(outside_alias);
        let identity = session.published_identity(&lease).unwrap();
        let publication = Arc::clone(session.publication.as_ref().unwrap());
        let readers = session
            .publication_read(publication.control.view())
            .unwrap()[0]
            .reader_counts;
        session.quiesce_published_reader(&lease, &[1]).unwrap();
        assert!(
            session.release_events.is_empty(),
            "quiescence must retire completed consumer events"
        );
        assert_eq!(session.published_identity(&lease).unwrap(), identity);
        assert!(lease.active);
        assert_eq!(
            session
                .publication_read(publication.control.view())
                .unwrap()[0]
                .reader_counts,
            readers,
            "quiescence must retain the actual acquired native reader"
        );
        session.release(&mut lease, &[1]).unwrap();
        drop(session);
        drop(owners);
        provider.memory().reap_pending_deallocations().unwrap();
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run; each fatal case uses a fresh process"]
    fn mutated_content_stops_the_dependent_cuda_consumer() {
        const CHILD_KIND: &str = "XLOG_CONTENT_GUARD_TEST_CHILD";
        const COMPLETED: &str = "content mutation produced a fatal CUDA completion error";
        let Some(kind) = std::env::var_os(CHILD_KIND) else {
            let qualified = concat!(
                module_path!(),
                "::mutated_content_stops_the_dependent_cuda_consumer"
            );
            let test_name = qualified.split_once("::").unwrap().1;
            for kind in ["publication", "witness"] {
                let output = std::process::Command::new(std::env::current_exe().unwrap())
                    .args([
                        "--exact",
                        test_name,
                        "--ignored",
                        "--nocapture",
                        "--test-threads=1",
                    ])
                    .env(CHILD_KIND, kind)
                    .output()
                    .unwrap();
                assert!(
                    output.status.success(),
                    "{kind} child did not verify a CUDA trap:\n{}\n{}",
                    String::from_utf8_lossy(&output.stdout),
                    String::from_utf8_lossy(&output.stderr)
                );
                assert!(
                    String::from_utf8_lossy(&output.stdout).contains(COMPLETED),
                    "{kind} child did not reach the typed CUDA completion check"
                );
            }
            return;
        };
        assert!(kind == "publication" || kind == "witness");
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let lease = session.acquire().unwrap();
        let alias = session
            .published_tensor(&lease, SemanticStateRole::SlowWeights, 0, 1)
            .unwrap();
        let captured =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let unchanged =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let changed =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let dependent = allocate_publication::<u8>(&provider, 4).unwrap();
        session
            .guard_published_content(&lease, &[(SemanticStateRole::SlowWeights, 0)], 1)
            .unwrap();
        let witness = session
            .capture_tensor_content(&lease, vec![captured], 1)
            .unwrap();
        session
            .verify_tensor_content(&lease, &witness, vec![unchanged], 1)
            .unwrap();
        // SAFETY: fixture aliases retain a real four-byte FP32 allocation in
        // this context; synchronization proves the unmodified guards completed.
        assert_eq!(
            unsafe { sys::cuStreamSynchronize(std::ptr::null_mut()) },
            sys::cudaError_enum::CUDA_SUCCESS
        );
        // SAFETY: this still-owned managed export retains its valid DLPack
        // descriptor and allocation until the disposable child exits.
        let tensor = unsafe { &(*alias.as_ptr()).dl_tensor };
        assert_eq!(tensor.byte_offset, 0);
        let pointer = tensor.data as usize as u64;
        // SAFETY: this is an external consumer writing its genuine managed
        // alias after capture, on the same stream it passes to verification.
        assert_eq!(
            unsafe { sys::cuMemsetD8Async(pointer, 0, 4, std::ptr::null_mut()) },
            sys::cudaError_enum::CUDA_SUCCESS
        );
        let guarded = if kind == "publication" {
            session.guard_published_content(&lease, &[(SemanticStateRole::SlowWeights, 0)], 1)
        } else {
            session.verify_tensor_content(&lease, &witness, vec![changed], 1)
        };
        // A fatal asynchronous launch can already surface at event handoff.
        // Only the typed CUDA completion below counts as expected rejection.
        if let Err(error) = guarded {
            eprintln!("content guard handoff: {error}");
        }
        // SAFETY: both retained buffers have four bytes in this context. The
        // native guard orders this dependent consumer on its declared stream.
        let copied = unsafe {
            sys::cuMemcpyDtoDAsync_v2(
                dependent.device_ptr_value(),
                pointer,
                4,
                std::ptr::null_mut(),
            )
        };
        assert!(matches!(
            copied,
            sys::cudaError_enum::CUDA_SUCCESS
                | sys::cudaError_enum::CUDA_ERROR_ILLEGAL_INSTRUCTION
                | sys::cudaError_enum::CUDA_ERROR_LAUNCH_FAILED
        ));
        // SAFETY: terminal completion is deliberately outside the hot guard
        // path and belongs only to this disposable child process's CUDA context.
        let completion = unsafe { sys::cuStreamSynchronize(std::ptr::null_mut()) };
        assert!(
            matches!(
                completion,
                sys::cudaError_enum::CUDA_ERROR_ILLEGAL_INSTRUCTION
                    | sys::cudaError_enum::CUDA_ERROR_LAUNCH_FAILED
            ),
            "unexpected CUDA completion: {completion:?}"
        );
        println!("{COMPLETED}");
        std::io::Write::flush(&mut std::io::stdout()).unwrap();
        // The context is poisoned by design. Exit only after checking the
        // actual CUDA error; the parent never accepts a panic as trap evidence.
        std::process::exit(0);
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run; aborted live owners use a fresh process"]
    fn aborted_session_retains_step_after_reader_retirement() {
        const CHILD: &str = "XLOG_ABORT_RETAINED_STEP_TEST_CHILD";
        const COMPLETED: &str =
            "aborted retained step kept its original owners without a bank reader";
        if std::env::var_os(CHILD).is_none() {
            let qualified = concat!(
                module_path!(),
                "::aborted_session_retains_step_after_reader_retirement"
            );
            let test_name = qualified.split_once("::").unwrap().1;
            let output = std::process::Command::new(std::env::current_exe().unwrap())
                .args([
                    "--exact",
                    test_name,
                    "--ignored",
                    "--nocapture",
                    "--test-threads=1",
                ])
                .env(CHILD, "1")
                .output()
                .unwrap();
            assert!(
                output.status.success(),
                "retained-step abort child failed:\n{}\n{}",
                String::from_utf8_lossy(&output.stdout),
                String::from_utf8_lossy(&output.stderr)
            );
            assert!(String::from_utf8_lossy(&output.stdout).contains(COMPLETED));
            return;
        }
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut lease = session.acquire().unwrap();
        let layout = session.publication.as_ref().unwrap().layouts[&(18, 0)];
        let live = Arc::new(allocate_publication::<u8>(&provider, 4).unwrap());
        upload_publication(&provider, &18.0f32.to_le_bytes(), &live).unwrap();
        let producer = || {
            content_test_export(
                Arc::clone(&live),
                provider.device().ordinal() as i32,
                crate::dlpack::DLDataType {
                    code: 2,
                    bits: 32,
                    lanes: 1,
                },
                layout,
                (0, 0),
            )
        };
        let witness = session
            .bind_model_content(&lease, vec![producer()], 1)
            .unwrap();
        session.release_published_reader(&mut lease, &[1]).unwrap();
        assert!(session.readers.is_empty());
        let before = session.host_io_stats();
        session.abort();
        assert!(matches!(
            session.retained_step_identity(&lease),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.verify_tensor_content(&lease, &witness, vec![producer()], 1),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.release(&mut lease, &[1]),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert_eq!(session.host_io_stats(), before);
        let prior = UNRELEASED_PUBLICATIONS.with(|owners| owners.borrow().len());
        drop(session);
        UNRELEASED_PUBLICATIONS.with(|owners| {
            let owners = owners.borrow();
            assert_eq!(owners.len(), prior + 1);
            let retained = owners.last().unwrap();
            assert!(retained._readers.is_empty());
            let step = &retained._steps[&lease.token];
            assert_eq!(step.identity, Some(lease.identity));
            assert!(matches!(
                step.content[witness.index].seals,
                TensorContentSeals::Model(_)
            ));
            assert_eq!(
                step.content[witness.index].tensors[0].data,
                live.device_ptr_value()
            );
        });
        println!("{COMPLETED}");
        std::io::Write::flush(&mut std::io::stdout()).unwrap();
        std::process::exit(0);
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run; aborted live owners use a fresh process"]
    fn aborted_session_refuses_existing_publication_and_witness_owners() {
        const CHILD: &str = "XLOG_ABORT_SESSION_TEST_CHILD";
        const COMPLETED: &str = "aborted session rejected retained publication and witness reuse";
        if std::env::var_os(CHILD).is_none() {
            let qualified = concat!(
                module_path!(),
                "::aborted_session_refuses_existing_publication_and_witness_owners"
            );
            let test_name = qualified.split_once("::").unwrap().1;
            let output = std::process::Command::new(std::env::current_exe().unwrap())
                .args([
                    "--exact",
                    test_name,
                    "--ignored",
                    "--nocapture",
                    "--test-threads=1",
                ])
                .env(CHILD, "1")
                .output()
                .unwrap();
            assert!(
                output.status.success(),
                "abort child did not verify unusable retained owners:\n{}\n{}",
                String::from_utf8_lossy(&output.stdout),
                String::from_utf8_lossy(&output.stderr)
            );
            assert!(
                String::from_utf8_lossy(&output.stdout).contains(COMPLETED),
                "abort child did not finish the native Poisoned checks"
            );
            return;
        }
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let lease = session.acquire().unwrap();
        let _outside_alias = session
            .published_tensor(&lease, SemanticStateRole::SlowWeights, 0, 1)
            .unwrap();
        let captured =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let unchanged =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let refused_capture =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let refused_verify =
            publication_test_alias(&mut session, &lease, SemanticStateRole::SlowWeights, 1);
        let witness = session
            .capture_tensor_content(&lease, vec![captured], 1)
            .unwrap();
        session
            .verify_tensor_content(&lease, &witness, vec![unchanged], 1)
            .unwrap();
        let identity = session.published_identity(&lease).unwrap();
        assert!(!session.published_range_keys(&lease).unwrap().is_empty());
        // SAFETY: native events order this context's declared default consumer;
        // complete the genuine pre-abort witness before testing invalidation.
        assert_eq!(
            unsafe { sys::cuStreamSynchronize(std::ptr::null_mut()) },
            sys::cudaError_enum::CUDA_SUCCESS
        );
        let before = session.host_io_stats();
        session.abort();
        session.abort();
        assert!(session.is_poisoned());
        assert_eq!(
            session.host_io_stats(),
            before,
            "abort must not synchronize or transfer retained content"
        );
        assert!(
            session.publication.is_some(),
            "abort must retain live publication storage"
        );
        assert!(
            session.readers.contains_key(&lease.token),
            "abort must retain existing reader owners"
        );
        assert_eq!(
            lease.identity, identity,
            "an aborted Session retains its lease's historical identity"
        );
        assert!(matches!(
            session.acquire(),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.published_identity(&lease),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.published_range_keys(&lease),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.published_tensor(&lease, SemanticStateRole::SlowWeights, 0, 1),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.published_prefix(&lease, 1),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.guard_published_content(&lease, &[(SemanticStateRole::SlowWeights, 0)], 1),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.capture_tensor_content(&lease, vec![refused_capture], 1),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.verify_tensor_content(&lease, &witness, vec![refused_verify], 1),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.capture(),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.launch(),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(matches!(
            session.bind_task_evaluation(task_binding_tests::task_spec([0, 1, 1], vec![])),
            Err(SemanticTransitionError::Poisoned)
        ));
        assert!(session.is_poisoned());
        println!("{COMPLETED}");
        std::io::Write::flush(&mut std::io::stdout()).unwrap();
        // Abort deliberately keeps historical owners unusable and retained.
        // Isolate their teardown from every other test; a panic is not success.
        std::process::exit(0);
    }

    // Codec-only sample: it intentionally has no native publication authority.
    // Actual hashes and replayable graph content are checked by restore on GPU.
    fn publication_material_sample() -> PublicationMaterial {
        let mut counts = [1u64; 55];
        counts[15] = 3;
        let layouts: BTreeMap<_, _> = (1..=55)
            .filter(|&role| is_tensor_role(role))
            .map(|role| {
                (
                    (role, 0),
                    SemanticTensorLayout {
                        role,
                        index: 0,
                        scalar_type: 6,
                        element_bytes: 4,
                        rank: 2,
                        logical_axis: u64::MAX,
                        dimensions: [1, 1, 0, 0],
                        strides_bytes: [4, 4, 0, 0],
                    },
                )
            })
            .collect();
        let mut ranges = Vec::new();
        for (ordinal, &count) in counts.iter().enumerate() {
            for index in 0..count {
                let role = ordinal as u64 + 1;
                let bytes = if role == 55 {
                    tensor_table_bytes(&layouts.values().copied().collect::<Vec<_>>(), false, &[])
                        .unwrap()
                } else if role == 44 {
                    let mut bytes = vec![0; 104];
                    bytes.extend_from_slice(&[44, index as u8, 0x80, 0xff]);
                    bytes
                } else if role == 32 {
                    publication_abi_bytes(&[AcknowledgementQueueHeader {
                        abi: 1,
                        payload_capacity_bytes: 128,
                        ..AcknowledgementQueueHeader::default()
                    }])
                } else {
                    vec![role as u8, index as u8, 0x80, 0xff]
                };
                ranges.push(PublicationMaterialRange {
                    range: PublicationRange {
                        role,
                        index,
                        generation: 1,
                        length_bytes: bytes.len() as u64,
                        storage_slot: ranges.len() as u64,
                        ..PublicationRange::default()
                    },
                    capacity: bytes.len() + 128,
                    bytes,
                });
            }
        }
        let header = PublicationHeader {
            abi: 1,
            model_generation: 7,
            authority_generation: 3,
            sealed_epoch: 8,
            publication_word: 16,
            range_count: ranges.len() as u64,
            state_digest: Identity256::from_bytes([29; 32]),
            ..PublicationHeader::default()
        };
        let mut model_memory = ModelMemoryGeometry::default();
        let mut model_allocations = Vec::new();
        for range in ranges
            .iter_mut()
            .filter(|range| matches!(range.range.role, 18..=25))
        {
            let ordinal = model_allocations.len() as u64;
            let mut bytes = vec![0; range.capacity];
            bytes[..range.bytes.len()].copy_from_slice(&range.bytes);
            range.range.backing_digest = Identity256::from_bytes(Sha256::digest(&bytes).into());
            model_memory.allocation_bytes.push(bytes.len() as u64);
            model_memory.storages.push(SemanticModelStorage {
                allocation: ordinal,
                byte_offset: 0,
                span_bytes: bytes.len() as u64,
            });
            model_memory.views.push(SemanticModelView {
                role: range.range.role,
                index: range.range.index,
                storage: ordinal,
                byte_offset: 0,
            });
            model_allocations.push(bytes);
        }
        let mut material = PublicationMaterial {
            bank: PublicationBank {
                header,
                source: [SemanticTextSlot::default(); 32],
                state: DeviceState::default(),
                receipts: [SemanticTransitionReceipt::default(); COMPONENT_COUNT],
            },
            contract: PublicationContract {
                abi: 1,
                model_generation: 7,
                authority_generation: 3,
                window_capacity: 32,
                role_count: 55,
                range_capacity: ranges.len() as u64,
                terminal_token_count: 1,
                model_contract_layout: SemanticModelContractLayout {
                    schema_begin: 104,
                    schema_bytes: 4,
                    schema_digest_offset: 0,
                    generation_offset: 32,
                    numerical_digest_offset: 40,
                    identity_offset: 72,
                },
                ..PublicationContract::default()
            },
            role_counts: counts,
            terminals: vec![3],
            layouts,
            model_memory,
            model_allocations,
            ranges,
            graph: SemanticRootMaterial {
                records: SemanticAdmissionRecords {
                    predicates: vec![],
                    records: vec![],
                    supports: vec![],
                },
                symbols: vec![],
                insertions: vec![],
                digest: [0; 32],
                extents: [0; 3],
                admission_base_digest: [0; 32],
                admission_base_extents: [0; 3],
            },
            learning_phases: Vec::new(),
        };
        publication_material_sample_runtime(&mut material);
        for range in &mut material.ranges {
            if !is_tensor_role(range.range.role) {
                range.range.digest = range.original_record_digest();
            }
        }
        material.bank.header.descriptor_digest = material.original_descriptor_digest();
        material
    }

    // Build the fixture's cold contract only after its allocation geometry is
    // chosen. This helper is not a repair operation on imported material.
    fn publication_material_sample_runtime(material: &mut PublicationMaterial) {
        material.bank.header.model_geometry_digest =
            material.model_memory.digest(&material.layouts).unwrap();
        let runtime = initial_runtime_contract_record(
            material.contract,
            &material.role_counts,
            &material.terminals,
            &material.layouts,
            material
                .ranges
                .iter()
                .filter(|item| item.range.role != 43)
                .map(|item| (item.range.role, item.range.index, item.capacity))
                .collect(),
            b"codec sample numerical mode",
            &material.model_memory,
        )
        .unwrap();
        let record = material
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 43)
            .unwrap();
        record.capacity = runtime.capacity_bytes;
        record.bytes = runtime.bytes;
        record.range.length_bytes = record.bytes.len() as u64;
        record.range.digest = record.original_record_digest();
    }

    #[test]
    fn publication_material_codec_preserves_all_ranges_and_rejects_incomplete_content() {
        let material = publication_material_sample();
        let bytes = material.encode().unwrap();
        let decoded = PublicationMaterial::decode(&bytes).unwrap();
        assert_eq!(decoded.encode().unwrap(), bytes);
        assert_eq!(decoded.ranges.len(), material.ranges.len());
        for (saved, actual) in material.ranges.iter().zip(&decoded.ranges) {
            assert_eq!(saved.bytes, actual.bytes);
            assert_eq!(saved.capacity, actual.capacity);
        }
        for boundary in [
            0,
            25,
            26,
            29,
            30,
            61,
            62,
            100,
            bytes.len() / 2,
            bytes.len() - 1,
        ] {
            assert!(PublicationMaterial::decode(&bytes[..boundary]).is_err());
        }
        let mut changed = bytes.clone();
        changed.push(0);
        assert!(PublicationMaterial::decode(&changed).is_err());
        changed = bytes.clone();
        changed[30] ^= 1;
        assert!(PublicationMaterial::decode(&changed).is_err());
        let mut incomplete = publication_material_sample();
        incomplete.ranges.pop();
        assert!(incomplete.encode().is_err());
        let mut reordered = publication_material_sample();
        reordered.ranges.swap(0, 1);
        assert!(reordered.encode().is_err());
        let mut address = publication_material_sample();
        address.contract.terminal_tokens = 0x1000;
        assert!(address.encode().is_err());
        let mut mismatched = publication_material_sample();
        mismatched.layouts.get_mut(&(4, 0)).unwrap().scalar_type = 2;
        assert!(mismatched.encode().is_err());
    }

    #[test]
    fn publication_material_runtime_preserves_mode_and_exact_self_capacity() {
        let material = publication_material_sample();
        let bytes = material.encode().unwrap();
        let restored = PublicationMaterial::decode(&bytes).unwrap();
        assert_eq!(
            restored.model_numerical_mode().unwrap(),
            b"codec sample numerical mode"
        );
        let record = restored
            .ranges
            .iter()
            .find(|item| item.range.role == 43)
            .unwrap();
        assert_eq!(record.capacity, record.bytes.len());
        assert_eq!(restored.encode().unwrap(), bytes);
        let capacities = material
            .ranges
            .iter()
            .map(|item| (item.range.role, item.range.index, item.capacity))
            .collect::<Vec<_>>();
        let mut relocated = material.contract;
        relocated.terminal_tokens = 0x1020304050607080;
        relocated.role_counts = 0x8070605040302010;
        relocated.semantic_owner = 99;
        let original = runtime_contract_bytes(
            relocated,
            &material.role_counts,
            &material.terminals,
            &material.layouts,
            &capacities,
            material.model_numerical_mode().unwrap(),
            &material.model_memory,
        )
        .unwrap();
        assert_eq!(
            original, record.bytes,
            "runtime addresses and owner handles are not portable identity"
        );
        assert_ne!(
            runtime_contract_bytes(
                relocated,
                &material.role_counts,
                &material.terminals,
                &material.layouts,
                &capacities,
                b"different complete mode",
                &material.model_memory
            )
            .unwrap(),
            original
        );
        assert!(runtime_contract_bytes(
            relocated,
            &material.role_counts,
            &material.terminals,
            &material.layouts,
            &capacities,
            b"",
            &material.model_memory
        )
        .is_err());
        assert!(
            initial_runtime_contract_record(
                relocated,
                &material.role_counts,
                &material.terminals,
                &material.layouts,
                capacities,
                b"mode",
                &material.model_memory
            )
            .is_err(),
            "caller runtime entry cannot be inserted twice"
        );
    }

    #[test]
    fn publication_material_runtime_binds_logical_contract_and_terminals() {
        let mut changed = publication_material_sample();
        changed.contract.max_position += 1;
        assert!(
            changed.encode().is_err(),
            "runtime record must bind the actual position contract"
        );
        let mut changed = publication_material_sample();
        changed.terminals[0] += 1;
        assert!(
            changed.encode().is_err(),
            "runtime record must retain actual terminal values"
        );
    }

    #[test]
    fn publication_material_runtime_binds_allocation_capacity() {
        let mut changed = publication_material_sample();
        changed
            .ranges
            .iter_mut()
            .find(|range| range.range.role == 2)
            .unwrap()
            .capacity += 1;
        assert!(
            changed.encode().is_err(),
            "runtime record must bind actual cold capacity"
        );
    }

    #[test]
    fn publication_material_runtime_rejects_changed_original_layout_table() {
        let material = publication_material_sample();
        assert_eq!(
            material.model_numerical_mode().unwrap(),
            b"codec sample numerical mode"
        );
        let table_index = material
            .ranges
            .iter()
            .position(|item| item.range.role == 55)
            .unwrap();
        for byte in 0..material.ranges[table_index].bytes.len() {
            let mut changed = publication_material_sample();
            changed.ranges[table_index].bytes[byte] ^= 1;
            assert!(
                changed.model_numerical_mode().is_err(),
                "changed table byte {byte}"
            );
        }
    }

    #[test]
    fn publication_material_runtime_rejects_resealed_layout_disagreement() {
        let mut changed = publication_material_sample();
        let table = changed
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 55)
            .unwrap();
        let (_, mut layouts, active) = decode_tensor_table(&table.bytes).unwrap();
        layouts[0].scalar_type = 2;
        table.bytes = tensor_table_bytes(&layouts, active.computed, &active.rows).unwrap();
        table.range.digest = table.original_record_digest();
        assert!(changed.model_numerical_mode().is_err());
    }

    #[test]
    fn publication_material_runtime_allows_sealed_active_table_changes() {
        let mut changed = publication_material_sample();
        let mode = changed.model_numerical_mode().unwrap().to_vec();
        let table = changed
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 55)
            .unwrap();
        let (_, layouts, _) = decode_tensor_table(&table.bytes).unwrap();
        table.bytes = tensor_table_bytes(&layouts, true, &[]).unwrap();
        table.range.digest = table.original_record_digest();
        assert_eq!(changed.model_numerical_mode().unwrap(), mode);
    }

    #[test]
    fn publication_material_runtime_refuses_opaque_replacement_even_if_resealed() {
        let mut changed = publication_material_sample();
        let runtime = changed
            .ranges
            .iter_mut()
            .find(|range| range.range.role == 43)
            .unwrap();
        runtime.bytes.fill(0);
        runtime.range.digest = runtime.original_record_digest();
        changed.bank.header.descriptor_digest = changed.original_descriptor_digest();
        assert!(
            changed.encode().is_err(),
            "opaque caller bytes are not the native runtime contract"
        );
    }

    #[test]
    fn capacity_prefix_export_preserves_extent_without_narrowing_shape() {
        let mut range = PublicationRange {
            role: 1,
            index: 0,
            generation: 1,
            length_bytes: 128,
            logical_begin: 0,
            logical_end: 2,
            ..PublicationRange::default()
        };
        let layout = committed_prefix_layout(&range, 8).unwrap();
        assert_eq!(layout.dimensions, [8, 8, 0, 0]);
        assert_eq!(tensor_layout_bytes(&layout).unwrap(), 512);
        assert_eq!(
            (range.logical_begin, range.logical_end, range.length_bytes),
            (0, 2, 128)
        );
        range.logical_end = 0;
        range.length_bytes = 0;
        assert_eq!(
            committed_prefix_layout(&range, 8).unwrap().dimensions,
            [8, 8, 0, 0]
        );
        assert!(committed_prefix_layout(
            &PublicationRange {
                logical_end: 9,
                length_bytes: 576,
                ..range
            },
            8
        )
        .is_err());
    }

    #[test]
    fn capacity_export_stream_rejects_ambiguous_default_handles() {
        assert!(dlpack_consumer_stream(0).is_err());
        assert!(dlpack_consumer_stream(2).is_err());
        assert!(dlpack_consumer_stream(1).unwrap().is_null());
        // Resolving a handle does not assert that the stream exists. The
        // driver checks the concrete handle during the ordered handoff.
        assert_eq!(dlpack_consumer_stream(4096).unwrap() as usize, 4096);
    }

    #[test]
    fn capacity_export_bounds_keep_seal_and_allocation_limits_distinct() {
        let range = PublicationRange {
            role: 1,
            index: 0,
            generation: 1,
            offset_bytes: 64,
            length_bytes: 128,
            logical_begin: 0,
            logical_end: 2,
            ..PublicationRange::default()
        };
        let layout = SemanticTensorLayout {
            role: 1,
            index: 0,
            scalar_type: 3,
            element_bytes: 8,
            rank: 2,
            logical_axis: 0,
            dimensions: [8, 8, 0, 0],
            strides_bytes: [64, 8, 0, 0],
        };
        assert_eq!(
            publication_export_span(&range, &layout, 576).unwrap(),
            64..576
        );
        assert!(publication_export_span(&range, &layout, 575).is_err());
        assert_eq!(
            (range.length_bytes, range.logical_begin, range.logical_end),
            (128, 0, 2)
        );
        for wrong in [
            PublicationRange {
                generation: 2,
                ..range
            },
            PublicationRange {
                offset_bytes: 65,
                ..range
            },
            PublicationRange {
                offset_bytes: u64::MAX - 7,
                ..range
            },
            PublicationRange {
                length_bytes: 513,
                ..range
            },
            PublicationRange {
                logical_end: 9,
                ..range
            },
            PublicationRange { index: 1, ..range },
        ] {
            assert!(publication_export_span(&wrong, &layout, 576).is_err());
        }
        let tensor = SemanticTensorLayout {
            role: 4,
            rank: 4,
            logical_axis: 2,
            dimensions: [1, 2, 8, 2],
            strides_bytes: [128, 64, 8, 4],
            scalar_type: 6,
            element_bytes: 4,
            ..layout
        };
        let tensor_range = PublicationRange {
            role: 4,
            offset_bytes: 0,
            length_bytes: 128,
            ..range
        };
        assert_eq!(
            publication_export_span(&tensor_range, &tensor, 128).unwrap(),
            0..128
        );
        let model = SemanticTensorLayout {
            role: 18,
            logical_axis: u64::MAX,
            ..tensor
        };
        assert_eq!(
            publication_export_span(
                &PublicationRange {
                    role: 18,
                    logical_begin: 0,
                    logical_end: 0,
                    ..tensor_range
                },
                &model,
                128
            )
            .unwrap(),
            0..128
        );
        assert!(publication_export_span(
            &PublicationRange {
                role: 18,
                length_bytes: 16,
                logical_begin: 0,
                logical_end: 0,
                ..tensor_range
            },
            &model,
            128
        )
        .is_err());
    }

    #[test]
    fn committed_prefix_export_layout_preserves_native_rows_and_empty_extent() {
        let range = PublicationRange {
            role: SemanticStateRole::PrefixSource as u64,
            index: 0,
            generation: 1,
            offset_bytes: 64,
            length_bytes: 128,
            logical_begin: 0,
            logical_end: 2,
            ..PublicationRange::default()
        };
        let layout = committed_prefix_layout(&range, 2).unwrap();
        assert_eq!(
            (layout.scalar_type, layout.element_bytes, layout.rank),
            (3, 8, 2)
        );
        assert_eq!(layout.dimensions, [2, 8, 0, 0]);
        assert_eq!(layout.strides_bytes, [64, 8, 0, 0]);
        assert_eq!(tensor_layout_bytes(&layout).unwrap(), 128);
        let row = SemanticTextSlot {
            token: 71,
            logical_position: 1,
            kind: 1,
            provenance: 2,
            valid: 1,
            committed: 1,
            recomputed: 1,
            provenance_record: 19,
        };
        let words = publication_abi_bytes(&[row])
            .as_chunks::<8>()
            .0
            .iter()
            .map(|bytes| u64::from_ne_bytes(*bytes))
            .collect::<Vec<_>>();
        assert_eq!(words, [71, 1, 1, 2, 1, 1, 1, 19]);
        let empty = committed_prefix_layout(
            &PublicationRange {
                length_bytes: 0,
                logical_end: 0,
                ..range
            },
            0,
        )
        .unwrap();
        assert_eq!(empty.dimensions, [0, 8, 0, 0]);
        assert_eq!(empty.strides_bytes, [64, 8, 0, 0]);
        assert_eq!(tensor_layout_bytes(&empty).unwrap(), 0);
    }

    #[test]
    fn committed_prefix_export_rejects_inconsistent_or_unaligned_extent() {
        let valid = PublicationRange {
            role: 1,
            index: 0,
            generation: 1,
            length_bytes: 128,
            logical_begin: 0,
            logical_end: 2,
            ..PublicationRange::default()
        };
        for wrong in [
            PublicationRange { role: 2, ..valid },
            PublicationRange { index: 1, ..valid },
            PublicationRange {
                offset_bytes: 1,
                ..valid
            },
            PublicationRange {
                logical_begin: 1,
                ..valid
            },
            PublicationRange {
                logical_end: 3,
                ..valid
            },
            PublicationRange {
                length_bytes: 64,
                ..valid
            },
            PublicationRange {
                length_bytes: 192,
                ..valid
            },
        ] {
            assert!(committed_prefix_layout(&wrong, 2).is_err());
        }
        assert!(committed_prefix_layout(&valid, u64::MAX).is_err());
        assert!(committed_prefix_layout(&valid, 0).is_err());
    }

    #[test]
    fn publication_material_decode_checks_original_descriptor_before_relocation() {
        let material = publication_material_sample();
        let original = material.encode().unwrap();
        assert!(PublicationMaterial::decode(&original).is_ok());

        for field in 0..4 {
            let mut changed = publication_material_sample();
            match field {
                0 => changed.bank.header.instance = Identity256::from_bytes([71; 32]),
                1 => changed.bank.header.recovered_instance = Identity256::from_bytes([72; 32]),
                2 => changed.bank.header.semantic_owner ^= 1,
                3 => changed.ranges[0].range.storage_slot ^= 1,
                _ => unreachable!(),
            }
            assert!(
                PublicationMaterial::decode(&changed.encode().unwrap()).is_err(),
                "cold decoding accepted changed original descriptor field {field}"
            );
        }
    }

    #[test]
    fn publication_material_decode_checks_original_record_bytes() {
        // These records contain origin coordinates omitted by normalized state
        // hashing. A saved descriptor is insufficient without their raw seals.
        for role in [2, 14, 15, 30, 33, 48] {
            let mut changed = publication_material_sample();
            let record = changed
                .ranges
                .iter_mut()
                .find(|item| item.range.role == role)
                .unwrap();
            record.bytes[0] ^= 1;
            assert!(
                PublicationMaterial::decode(&changed.encode().unwrap()).is_err(),
                "cold decoding accepted altered original record {role}"
            );
        }
        for word in [1, 5, 6, 39] {
            let mut changed = publication_material_sample();
            let record = changed
                .ranges
                .iter_mut()
                .find(|item| item.range.role == 33)
                .unwrap();
            record.bytes = publication_abi_bytes(&[AttemptReceipt::default()]);
            record.range.length_bytes = record.bytes.len() as u64;
            record.capacity = record.bytes.len();
            record.range.digest = record.original_record_digest();
            publication_material_sample_runtime(&mut changed);
            changed.bank.header.descriptor_digest = changed.original_descriptor_digest();
            assert!(PublicationMaterial::decode(&changed.encode().unwrap()).is_ok());
            changed
                .ranges
                .iter_mut()
                .find(|item| item.range.role == 33)
                .unwrap()
                .bytes[word * 8] ^= 1;
            assert!(
                PublicationMaterial::decode(&changed.encode().unwrap()).is_err(),
                "cold decoding accepted altered normalized-out attempt word {word}"
            );
        }
    }

    #[test]
    fn checkpoint_projection_uses_validated_original_publication() {
        let material = publication_material_sample();
        let header = material.bank.header;
        let projection =
            SemanticTransitionSession::state_material_projection(&material.encode().unwrap())
                .unwrap();
        assert_eq!(projection.publication.instance, header.instance);
        assert_eq!(projection.publication.word, header.publication_word);
        assert_eq!(projection.publication.logical_digest, header.logical_digest);
        assert_eq!(projection.publication.state_digest, header.state_digest);
        assert_eq!(projection.semantic_root, header.semantic_digest);
        assert_eq!(projection.model_generation, header.model_generation);
    }

    // Fixed native ABI records exercise the cold evidence parser. They are not
    // claimed to be a device execution or historical publication authority.
    fn replay_material_sample() -> (PublicationMaterial, PublicationReplayEvidence) {
        let mut predecessor = publication_material_sample();
        predecessor.bank.header.instance = Identity256::from_bytes([11; 32]);
        predecessor.bank.header.logical_digest = Identity256::from_bytes([12; 32]);
        for (role, bytes) in [
            (
                30,
                publication_abi_bytes(&[IntentQueueHeader {
                    abi: 1,
                    ..IntentQueueHeader::default()
                }]),
            ),
            (33, publication_abi_bytes(&[AttemptReceipt::default()])),
        ] {
            let item = predecessor
                .ranges
                .iter_mut()
                .find(|item| item.range.role == role)
                .unwrap();
            item.range.length_bytes = bytes.len() as u64;
            item.capacity = bytes.len();
            item.bytes = bytes;
        }
        // The sample's final allocation capacities precede its cold contract,
        // exactly as in initial publication. Imported evidence is never resealed.
        publication_material_sample_runtime(&mut predecessor);
        for item in &mut predecessor.ranges {
            if !is_tensor_role(item.range.role) {
                item.range.digest = item.original_record_digest();
            }
        }
        predecessor.bank.header.descriptor_digest = predecessor.original_descriptor_digest();
        let mut evidence = PublicationReplayEvidence {
            successor: SemanticPublishedIdentity {
                instance: predecessor.bank.header.instance,
                word: 19,
                logical_digest: Identity256::from_bytes([13; 32]),
                state_digest: Identity256::default(),
            },
            ranges: predecessor
                .ranges
                .iter()
                .filter(|item| REPLAY_EVIDENCE_ROLES.contains(&item.range.role))
                .cloned()
                .collect(),
        };
        let attempt = AttemptReceipt {
            abi: 2,
            transition_kind: 2,
            instance: evidence.successor.instance,
            base_word: predecessor.bank.header.publication_word,
            next_word: evidence.successor.word,
            logical_digest: evidence.successor.logical_digest,
            action_receipts_digest: Identity256::from_bytes(Sha256::digest([]).into()),
            semantic_receipts_digest: Identity256::from_bytes([14; 32]),
            coverage_digest: Identity256::from_bytes([15; 32]),
            replay_head_digest: evidence.range(27).unwrap().logical_record_digest().unwrap(),
            intent_head_digest: evidence.range(30).unwrap().logical_record_digest().unwrap(),
            acknowledgement_head_digest: evidence
                .range(32)
                .unwrap()
                .logical_record_digest()
                .unwrap(),
            previous_attempt_digest: predecessor
                .ranges
                .iter()
                .find(|item| item.range.role == 33)
                .unwrap()
                .logical_record_digest()
                .unwrap(),
            ..AttemptReceipt::default()
        };
        evidence.ranges.last_mut().unwrap().bytes = publication_abi_bytes(&[attempt]);
        seal_replay_sample(&mut evidence);
        (predecessor, evidence)
    }

    fn seal_replay_sample(evidence: &mut PublicationReplayEvidence) {
        let item = evidence.ranges.last_mut().unwrap();
        let mut attempt = item.attempt().unwrap();
        attempt.receipt_digest = item.logical_record_digest().unwrap();
        item.bytes = publication_abi_bytes(&[attempt]);
        for item in &mut evidence.ranges {
            item.range.digest = item.original_record_digest();
        }
        evidence.successor.state_digest = evidence.state_digest().unwrap();
    }

    #[test]
    fn selected_recompute_requires_the_current_sealed_native_attempt() {
        let (mut selected, mut evidence) = replay_material_sample();
        let current_coverage = CompletionCoverage {
            abi: 1,
            model_generation: selected.bank.header.model_generation,
            ..CompletionCoverage::default()
        };
        let coverage_range = selected
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 14)
            .unwrap();
        coverage_range.bytes = publication_abi_bytes(&[current_coverage]);
        coverage_range.capacity = coverage_range.bytes.len();
        coverage_range.range.length_bytes = coverage_range.bytes.len() as u64;
        coverage_range.range.digest = coverage_range.original_record_digest();
        let coverage = coverage_range.logical_record_digest().unwrap();
        let attempt_range = evidence.ranges.last_mut().unwrap();
        let mut attempt = attempt_range.attempt().unwrap();
        attempt.coverage_digest = coverage;
        attempt_range.bytes = publication_abi_bytes(&[attempt]);
        seal_replay_sample(&mut evidence);
        let previous_word = selected.bank.header.publication_word;
        selected.bank.header.base_word = previous_word;
        selected.bank.header.publication_word = evidence.successor.word;
        selected.bank.header.logical_digest = evidence.successor.logical_digest;
        selected.bank.header.state_digest = evidence.successor.state_digest;
        selected.bank.header.terminal = 0;
        for replacement in &evidence.ranges {
            let original = selected
                .ranges
                .iter_mut()
                .find(|item| {
                    (item.range.role, item.range.index)
                        == (replacement.range.role, replacement.range.index)
                })
                .unwrap();
            *original = replacement.clone();
        }
        assert!(selected.require_successful_recompute().is_ok());
        let attempt_range = selected
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 33)
            .unwrap();
        let original_attempt = attempt_range.bytes.clone();
        let mut update = attempt_range.attempt().unwrap();
        update.transition_kind = 4;
        attempt_range.bytes = publication_abi_bytes(&[update]);
        assert!(selected.require_successful_recompute().is_err());
        selected
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 33)
            .unwrap()
            .bytes = original_attempt;
        selected.bank.header.publication_word += 2;
        assert!(selected.require_successful_recompute().is_err());
    }

    #[test]
    fn semantic_replay_material_requires_complete_linked_evidence() {
        let (predecessor, evidence) = replay_material_sample();
        let bytes = predecessor.encode().unwrap();
        let parse = |evidence: &[u8]| {
            SemanticReplayMaterial::decode(
                &bytes,
                evidence,
                predecessor.bank.header.logical_digest,
                evidence_successor_logical(),
            )
        };
        let decoded = parse(&evidence.encode().unwrap()).unwrap();
        assert_eq!(
            decoded.predecessor_identity().instance,
            predecessor.bank.header.instance
        );
        assert_eq!(decoded.successor_identity(), evidence.successor);
        assert_eq!(decoded.transition_kind(), SemanticTransitionKind::Recompute);
        assert!(parse(&bytes).is_err());
        assert!(parse(&[]).is_err());
        let mut truncated = evidence.encode().unwrap();
        truncated.pop();
        assert!(parse(&truncated).is_err());
        let mut trailing = evidence.encode().unwrap();
        trailing.push(0);
        assert!(parse(&trailing).is_err());
        for change in 0..5 {
            let (_, mut changed) = replay_material_sample();
            match change {
                0 => changed.successor.instance = Identity256::from_bytes([90; 32]),
                1 => changed.successor.word += 4,
                2 => changed.successor.state_digest = Identity256::default(),
                3 => {
                    changed.ranges.remove(0);
                }
                4 => {
                    let item = changed.ranges.last_mut().unwrap();
                    let mut attempt = item.attempt().unwrap();
                    attempt.previous_attempt_digest = Identity256::from_bytes([91; 32]);
                    item.bytes = publication_abi_bytes(&[attempt]);
                    seal_replay_sample(&mut changed);
                }
                _ => unreachable!(),
            }
            assert!(
                parse(&changed.encode().unwrap()).is_err(),
                "accepted altered native evidence {change}"
            );
        }
    }

    fn evidence_successor_logical() -> Identity256 {
        Identity256::from_bytes([13; 32])
    }

    #[test]
    fn semantic_replay_provenance_preserves_original_authority_and_decision() {
        let (predecessor, evidence) = replay_material_sample();
        let replay = SemanticReplayMaterial::decode(
            &predecessor.encode().unwrap(),
            &evidence.encode().unwrap(),
            predecessor.bank.header.logical_digest,
            evidence.successor.logical_digest,
        )
        .unwrap();
        let authority = predecessor
            .ranges
            .iter()
            .find(|item| item.range.role == 38)
            .unwrap()
            .clone();
        let mut decision = predecessor
            .ranges
            .iter()
            .find(|item| item.range.role == 39)
            .unwrap()
            .clone();
        decision.bytes[0] ^= 1;
        decision.range.digest = decision.original_record_digest();
        let mut provenance = PublicationReplayProvenance {
            predecessor: replay.predecessor_identity(),
            authority,
            decision,
        };
        let bytes = provenance.encode().unwrap();
        assert_eq!(
            replay.verify_provenance(&bytes).unwrap(),
            provenance.decision.bytes
        );
        assert!(replay.verify_provenance(&bytes[..bytes.len() - 1]).is_err());
        let mut trailing = bytes.clone();
        trailing.push(0);
        assert!(replay.verify_provenance(&trailing).is_err());
        assert!(replay
            .verify_provenance(&predecessor.encode().unwrap())
            .is_err());
        provenance.predecessor.word += 2;
        assert!(replay
            .verify_provenance(&provenance.encode().unwrap())
            .is_err());
        provenance.predecessor = replay.predecessor_identity();
        provenance.authority.bytes[0] ^= 1;
        provenance.authority.range.digest = provenance.authority.original_record_digest();
        assert!(replay
            .verify_provenance(&provenance.encode().unwrap())
            .is_err());
        provenance.authority = predecessor
            .ranges
            .iter()
            .find(|item| item.range.role == 38)
            .unwrap()
            .clone();
        provenance.decision.bytes[0] ^= 1;
        assert!(replay
            .verify_provenance(&provenance.encode().unwrap())
            .is_err());
    }

    #[test]
    fn semantic_replay_material_normalizes_only_native_audit_words() {
        let (_, evidence) = replay_material_sample();
        let mut attempt = evidence.range(33).unwrap().clone();
        let original = attempt.logical_record_digest().unwrap();
        for word in [1, 4, 5, 6, 39, 42] {
            attempt.bytes[word * 8] ^= 1;
        }
        assert_eq!(attempt.logical_record_digest().unwrap(), original);
        assert_ne!(
            attempt.original_record_digest(),
            evidence.range(33).unwrap().original_record_digest()
        );
        attempt.bytes[7 * 8] ^= 1;
        assert_ne!(attempt.logical_record_digest().unwrap(), original);
        for role in [27, 28, 31, 32] {
            let mut item = evidence.range(role).unwrap().clone();
            let original = item.logical_record_digest().unwrap();
            item.bytes[0] ^= 1;
            assert_ne!(
                item.logical_record_digest().unwrap(),
                original,
                "normalized opaque role {role}"
            );
        }
    }

    fn replay_codebook_sample() -> PublicationMaterialRange {
        let mut words: Vec<u64> = (0..28).collect();
        words[8] = 25 * 8;
        words[9] = 3 * 8;
        let bytes = publication_abi_bytes(&words);
        let mut item = PublicationMaterialRange {
            range: PublicationRange {
                role: 48,
                generation: 1,
                length_bytes: bytes.len() as u64,
                ..PublicationRange::default()
            },
            capacity: bytes.len(),
            bytes,
        };
        item.range.digest = item.original_record_digest();
        item
    }

    #[test]
    fn semantic_replay_receipt_hashes_preserve_every_nonruntime_field() {
        let codebook = replay_codebook_sample();
        let receipts = [SemanticTransitionReceipt {
            catalogue_generation: CATALOGUE_GENERATION,
            admission_binding: Identity256::from_bytes([17; 32]),
            choice: 5,
            ..SemanticTransitionReceipt::default()
        }];
        let expected = publication_action_receipts_digest(&codebook, &receipts).unwrap();
        for word in 0..codebook.bytes.len() / 8 {
            if matches!(word, 8 | 9) {
                continue;
            }
            let mut changed = codebook.clone();
            changed.bytes[word * 8] ^= 1;
            let equal =
                publication_action_receipts_digest(&changed, &receipts).unwrap() == expected;
            assert_eq!(
                equal,
                matches!(word, 14..=16 | 21..=24),
                "codebook word {word}"
            );
        }
        let mut changed = receipts;
        changed[0].admission_binding = Identity256::from_bytes([18; 32]);
        assert_eq!(
            publication_action_receipts_digest(&codebook, &changed).unwrap(),
            expected
        );
        changed[0].choice += 1;
        assert_ne!(
            publication_action_receipts_digest(&codebook, &changed).unwrap(),
            expected
        );
        let mut legacy = receipts;
        legacy[0].catalogue_generation = 0;
        let legacy_digest = publication_action_receipts_digest(&codebook, &legacy).unwrap();
        legacy[0].admission_binding = Identity256::from_bytes([18; 32]);
        assert_ne!(
            publication_action_receipts_digest(&codebook, &legacy).unwrap(),
            legacy_digest
        );
        assert_eq!(
            publication_action_receipts_digest(&codebook, &[]).unwrap(),
            Identity256::from_bytes(Sha256::digest([]).into())
        );
        let semantic = [[0u64; 42]; 7];
        let expected = publication_semantic_receipts_digest(&semantic);
        for ordinal in 0..semantic.len() {
            for word in 0..42 {
                let mut changed = semantic;
                changed[ordinal][word] = 1;
                assert_eq!(
                    publication_semantic_receipts_digest(&changed) == expected,
                    matches!(word, 3..=12 | 34..=41),
                    "semantic receipt {ordinal} word {word}"
                );
            }
        }
        let header = IntentQueueHeader {
            abi: 1,
            count: 2,
            capacity: 2,
            ..IntentQueueHeader::default()
        };
        let mut bytes = publication_abi_bytes(&[header]);
        bytes.extend(publication_abi_bytes(&[IntentEntry::default(); 2]));
        let intent = PublicationMaterialRange {
            range: PublicationRange {
                role: 30,
                logical_end: 2,
                length_bytes: bytes.len() as u64,
                ..PublicationRange::default()
            },
            capacity: bytes.len(),
            bytes,
        };
        let expected = intent.logical_record_digest().unwrap();
        for ordinal in 0..2 {
            for word in 0..43 {
                let mut changed = intent.clone();
                changed.bytes[size_of::<IntentQueueHeader>()
                    + ordinal * size_of::<IntentEntry>()
                    + word * 8] ^= 1;
                assert_eq!(
                    changed.logical_record_digest().unwrap() == expected,
                    matches!(word, 30..=34),
                    "intent entry {ordinal} word {word}"
                );
            }
        }
    }

    #[test]
    fn semantic_replay_observed_attempt_checks_actual_receipts_and_coverage() {
        let (predecessor, mut evidence) = replay_material_sample();
        let mut bank = predecessor.bank;
        bank.header.instance = evidence.successor.instance;
        bank.header.base_word = predecessor.bank.header.publication_word;
        bank.header.publication_word = evidence.successor.word;
        bank.header.sealed_epoch = evidence.successor.word >> 1;
        bank.header.logical_digest = evidence.successor.logical_digest;
        bank.header.proposal = predecessor.bank.header.proposal + 1;
        bank.state.proposal = predecessor.bank.header.proposal;
        bank.state.next_proposal = bank.header.proposal;
        bank.state.blocks = COMPONENT_COUNT as u64;
        bank.receipts[0].catalogue_generation = CATALOGUE_GENERATION;
        let codebook = replay_codebook_sample();
        let component_receipts_digest =
            publication_action_receipts_digest(&codebook, &bank.receipts).unwrap();
        let semantic_receipts_digest =
            publication_semantic_receipts_digest(&bank.state.semantic_receipts);
        bank.state.action_batch = SemanticActionBatchReceipt {
            abi: 1,
            proposal: bank.state.proposal,
            stream_serial: bank.state.stream_serial,
            family_id: u64::from(bank.state.family_id),
            action_law_generation: bank.state.catalogue_generation,
            model_generation: u64::from(bank.state.model_generation),
            actor_eligible: bank.state.actor_eligible,
            component_count: COMPONENT_COUNT as u64,
            candidate_count: 3,
            winner: bank.state.task_evaluation.winner,
            total_return_bits: bank.state.task_evaluation.return_value as u64,
            base_word: bank.header.base_word,
            next_word: bank.header.publication_word,
            rng_base: bank.state.proposal * COMPONENT_COUNT as u64,
            rng_span: COMPONENT_COUNT as u64,
            rng_successor: bank.state.next_proposal * COMPONENT_COUNT as u64,
            catalogue_digest: bank.state.catalogue_digest,
            component_receipts_digest,
            semantic_receipts_digest,
            candidate_roots: [Identity256::default(); 3],
            base_logical_digest: predecessor.bank.header.logical_digest,
            execution_work: bank.state.execution_work,
        };
        bank.state.action_batch_root = publication_action_batch_root(&bank.state.action_batch);
        let mut completion = CompletionCoverage {
            abi: 1,
            instance: bank.header.instance,
            base_word: bank.header.base_word,
            ..CompletionCoverage::default()
        };
        let bytes = publication_abi_bytes(&[completion]);
        let mut coverage = PublicationMaterialRange {
            range: PublicationRange {
                role: 14,
                generation: 1,
                length_bytes: bytes.len() as u64,
                ..PublicationRange::default()
            },
            capacity: bytes.len(),
            bytes,
        };
        completion.receipt_digest = coverage.logical_record_digest().unwrap();
        coverage.bytes = publication_abi_bytes(&[completion]);
        coverage.range.digest = coverage.original_record_digest();
        let item = evidence.ranges.last_mut().unwrap();
        let mut attempt = item.attempt().unwrap();
        attempt.transition_kind = 1;
        attempt.action_receipts_digest = bank.state.action_batch_root;
        attempt.semantic_receipts_digest = semantic_receipts_digest;
        attempt.coverage_digest = coverage.logical_record_digest().unwrap();
        item.bytes = publication_abi_bytes(&[attempt]);
        seal_replay_sample(&mut evidence);
        bank.header.state_digest = evidence.successor.state_digest;
        assert_eq!(
            evidence.validate(&predecessor).unwrap(),
            SemanticTransitionKind::Proposal
        );
        evidence
            .validate_observed(&predecessor, &bank, &coverage, &codebook)
            .unwrap();

        let mut changed = bank;
        changed.receipts[0].choice += 1;
        assert!(evidence
            .validate_observed(&predecessor, &changed, &coverage, &codebook)
            .is_err());
        changed = bank;
        changed.state.semantic_receipts[0][13] += 1;
        assert!(evidence
            .validate_observed(&predecessor, &changed, &coverage, &codebook)
            .is_err());
        changed = bank;
        changed.state.semantic_receipts[0][3] += 1;
        evidence
            .validate_observed(&predecessor, &changed, &coverage, &codebook)
            .unwrap();
        changed = bank;
        changed.state.blocks = 0;
        assert!(evidence
            .validate_observed(&predecessor, &changed, &coverage, &codebook)
            .is_err());
        changed = bank;
        changed.header.base_word += 2;
        assert!(evidence
            .validate_observed(&predecessor, &changed, &coverage, &codebook)
            .is_err());
        let mut changed_coverage = coverage.clone();
        changed_coverage.bytes[6 * 8] ^= 1;
        changed_coverage.range.digest = changed_coverage.original_record_digest();
        assert!(evidence
            .validate_observed(&predecessor, &bank, &changed_coverage, &codebook)
            .is_err());
        let mut changed_codebook = codebook.clone();
        changed_codebook.bytes[25 * 8] ^= 1;
        changed_codebook.range.digest = changed_codebook.original_record_digest();
        assert!(evidence
            .validate_observed(&predecessor, &bank, &coverage, &changed_codebook)
            .is_err());
        let item = evidence.ranges.last_mut().unwrap();
        let mut attempt = item.attempt().unwrap();
        attempt.semantic_receipts_digest = Identity256::from_bytes([92; 32]);
        item.bytes = publication_abi_bytes(&[attempt]);
        seal_replay_sample(&mut evidence);
        bank.header.state_digest = evidence.successor.state_digest;
        evidence.validate(&predecessor).unwrap();
        assert!(evidence
            .validate_observed(&predecessor, &bank, &coverage, &codebook)
            .is_err());
    }

    #[test]
    fn publication_material_codebooks_relocate_only_runtime_coordinates() {
        let original: Vec<u64> = (0..48).collect();
        let mut actual = original.clone();
        for word in (14..=16).chain(21..=24) {
            actual[word] += 500;
        }
        let saved = publication_abi_bytes(&original);
        assert_eq!(
            relocate_publication_codebooks(&saved, &actual).unwrap(),
            publication_abi_bytes(&actual)
        );
        for word in (0..14).chain(17..=20).chain(25..48) {
            let mut corrupt = actual.clone();
            corrupt[word] += 1;
            assert!(
                relocate_publication_codebooks(&saved, &corrupt).is_err(),
                "logical word {word}"
            );
        }
        assert!(relocate_publication_codebooks(&saved[..saved.len() - 1], &actual).is_err());
        assert!(relocate_publication_codebooks(&saved, &actual[..47]).is_err());
        assert!(relocate_publication_codebooks(&[], &[]).is_err());
    }

    type StepInputGeometryFixture = (
        [Vec<PublicationRange>; 2],
        BTreeMap<(u64, u64), SemanticTensorLayout>,
        Vec<usize>,
    );

    fn step_input_geometry_fixture() -> StepInputGeometryFixture {
        let mut layouts = BTreeMap::new();
        let mut banks = [Vec::new(), Vec::new()];
        let mut sizes = Vec::new();
        for (role, index) in std::iter::once(1)
            .chain(3..=13)
            .chain(15..=17)
            .chain(std::iter::once(44))
            .flat_map(|role| (0..if role == 16 { 3 } else { 1 }).map(move |index| (role, index)))
        {
            let layout = if role == 1 {
                SemanticTensorLayout {
                    role,
                    index: 0,
                    scalar_type: 3,
                    element_bytes: 8,
                    rank: 2,
                    logical_axis: 0,
                    dimensions: [64, 8, 0, 0],
                    strides_bytes: [64, 8, 0, 0],
                }
            } else {
                canonical_tensor_layout(SemanticTensorLayout {
                    role,
                    index: 0,
                    scalar_type: if role == 7 { 5 } else { 6 },
                    element_bytes: if role == 7 { 2 } else { 4 },
                    rank: 4,
                    logical_axis: if role <= 5 { 2 } else { u64::MAX },
                    dimensions: [1, 2, 64, 3],
                    strides_bytes: [0; 4],
                })
                .unwrap()
            };
            if (4..=13).contains(&role) {
                layouts.insert((role, 0), layout);
            }
            let capacity = if role == 3 {
                32
            } else if role == 44 {
                108
            } else if role == 15 {
                2 * size_of::<RawFeedbackRecord>()
            } else if matches!(role, 16 | 17) {
                40 + index as usize * 8
            } else {
                tensor_layout_bytes(&layout).unwrap()
            };
            let shared = matches!(role, 1 | 16 | 17);
            let first_slot = sizes.len();
            sizes.push(capacity);
            if !shared {
                sizes.push(capacity);
            }
            for (bank, directory) in banks.iter_mut().enumerate() {
                directory.push(PublicationRange {
                    role,
                    index,
                    storage_slot: (first_slot + usize::from(!shared) * bank) as u64,
                    generation: 1,
                    length_bytes: if role == 1 {
                        64
                    } else if role == 4 || role == 5 {
                        24
                    } else {
                        capacity as u64
                    },
                    logical_end: u64::from(matches!(role, 1 | 4 | 5 | 15)),
                    ..PublicationRange::default()
                });
            }
        }
        (banks, layouts, sizes)
    }

    #[test]
    fn step_input_geometry_preserves_exact_roster_and_full_shared_capacity() {
        let (banks, layouts, sizes) = step_input_geometry_fixture();
        let plan = plan_step_inputs(&banks, &layouts, 64, &sizes).unwrap();
        assert_eq!(
            plan.iter()
                .map(|input| (input.role, input.index))
                .collect::<Vec<_>>(),
            std::iter::once((1, 0))
                .chain((3..=13).map(|role| (role, 0)))
                .chain([(15, 0), (16, 0), (16, 1), (16, 2), (17, 0), (44, 0),])
                .collect::<Vec<_>>()
        );
        assert_eq!(plan[0].banks[0].span.len(), 64 * size_of::<SourceSlot>());
        assert_eq!(plan[1].banks[0].span.len(), 32);
        for input in plan.iter().filter(|input| matches!(input.role, 4 | 5)) {
            assert_eq!(input.banks[0].span.len(), 2 * 64 * 3 * 4);
        }
        assert_eq!(size_of::<PublicationStepInput>(), 160);
    }

    #[test]
    fn step_input_geometry_retains_raw_feedback_and_every_statement_record() {
        let (banks, layouts, sizes) = step_input_geometry_fixture();
        let plan = plan_step_inputs(&banks, &layouts, 64, &sizes).unwrap();
        let records = plan
            .iter()
            .filter(|input| matches!(input.role, 15..=17))
            .collect::<Vec<_>>();
        assert_eq!(
            records
                .iter()
                .map(|input| (input.role, input.index, input.banks[0].span.len()))
                .collect::<Vec<_>>(),
            vec![
                (15, 0, 768),
                (16, 0, 40),
                (16, 1, 48),
                (16, 2, 56),
                (17, 0, 40),
            ]
        );
        assert!(records
            .iter()
            .all(|input| input.layout.scalar_type == 1 && input.layout.element_bytes == 1));
        let mut missing = banks.clone();
        missing[1].retain(|range| (range.role, range.index) != (16, 2));
        assert!(plan_step_inputs(&missing, &layouts, 64, &sizes).is_err());
        let mut gapped = banks.clone();
        for bank in &mut gapped {
            bank.iter_mut()
                .find(|range| (range.role, range.index) == (16, 1))
                .unwrap()
                .index = 3;
        }
        assert!(plan_step_inputs(&gapped, &layouts, 64, &sizes).is_err());
        let mut shared_raw = banks;
        let slot = shared_raw[0]
            .iter()
            .find(|range| range.role == 15)
            .unwrap()
            .storage_slot;
        shared_raw[1]
            .iter_mut()
            .find(|range| range.role == 15)
            .unwrap()
            .storage_slot = slot;
        assert!(plan_step_inputs(&shared_raw, &layouts, 64, &sizes).is_err());
    }

    #[test]
    fn feedback_record_material_preserves_original_seal_and_rejects_changed_content() {
        let mut original = PublicationMaterialRange {
            range: PublicationRange {
                role: 15,
                generation: 1,
                length_bytes: 768,
                logical_end: 1,
                ..PublicationRange::default()
            },
            capacity: 768,
            bytes: vec![0; 768],
        };
        original.range.digest = original.original_record_digest();
        let material = original.clone().into_feedback_record().unwrap();
        assert_eq!(material.identity, original.range.digest);
        assert_eq!(
            (
                material.logical_begin,
                material.logical_end,
                material.capacity_bytes
            ),
            (0, 1, 768)
        );
        assert_eq!(material.bytes, original.bytes);
        let mut changed = original.clone();
        changed.bytes[0] ^= 1;
        assert!(changed.into_feedback_record().is_err());
        let mut changed = original.clone();
        changed.range.logical_end = 2;
        assert!(changed.into_feedback_record().is_err());
        let mut changed = original;
        changed.range.role = 18;
        assert!(changed.into_feedback_record().is_err());
    }

    #[test]
    fn step_input_geometry_rejects_missing_duplicate_and_noncanonical_coordinates() {
        let (banks, layouts, sizes) = step_input_geometry_fixture();
        let mut missing = banks.clone();
        missing[1].remove(4);
        assert!(plan_step_inputs(&missing, &layouts, 64, &sizes).is_err());
        let mut duplicate = banks.clone();
        let repeated = duplicate[0][4];
        duplicate[0].push(repeated);
        assert!(plan_step_inputs(&duplicate, &layouts, 64, &sizes).is_err());
        let mut wrong_index = banks;
        wrong_index[0][4].index = 1;
        assert!(plan_step_inputs(&wrong_index, &layouts, 64, &sizes).is_err());
    }

    #[test]
    fn step_input_geometry_requires_shared_prefix_and_isolated_key_value_caches() {
        let (banks, layouts, sizes) = step_input_geometry_fixture();
        {
            let role = 1;
            let mut changed = banks.clone();
            changed[1]
                .iter_mut()
                .find(|range| range.role == role)
                .unwrap()
                .storage_slot += 1;
            assert!(plan_step_inputs(&changed, &layouts, 64, &sizes).is_err());
        }
        for role in [4, 5].into_iter().chain(std::iter::once(3)).chain(6..=13) {
            let mut changed = banks.clone();
            let slot = changed[0]
                .iter()
                .find(|range| range.role == role)
                .unwrap()
                .storage_slot;
            changed[1]
                .iter_mut()
                .find(|range| range.role == role)
                .unwrap()
                .storage_slot = slot;
            assert!(plan_step_inputs(&changed, &layouts, 64, &sizes).is_err());
        }
    }

    #[test]
    fn step_input_geometry_checks_canonical_dtype_spans_and_allocation_bounds() {
        let (banks, layouts, sizes) = step_input_geometry_fixture();
        let plan = plan_step_inputs(&banks, &layouts, 64, &sizes).unwrap();
        let bf16 = plan.iter().find(|input| input.role == 7).unwrap();
        assert_eq!(
            (
                bf16.layout.scalar_type,
                bf16.layout.element_bytes,
                bf16.banks[0].span.len()
            ),
            (5, 2, 768)
        );
        let mut wrong = layouts.clone();
        wrong.get_mut(&(7, 0)).unwrap().strides_bytes[2] += 2;
        assert!(plan_step_inputs(&banks, &wrong, 64, &sizes).is_err());
        let mut short = sizes;
        short[banks[1]
            .iter()
            .find(|range| range.role == 7)
            .unwrap()
            .storage_slot as usize] -= 1;
        assert!(plan_step_inputs(&banks, &layouts, 64, &short).is_err());
        assert!(
            step_input_overlap(104, 0, 100, 8).unwrap(),
            "empty native aliases must still preserve their origin"
        );
        assert!(!step_input_overlap(108, 0, 100, 8).unwrap());
        assert!(step_input_overlap(96, 8, 100, 8).unwrap());
        assert!(step_input_overlap(u64::MAX, 2, 100, 8).is_err());
    }

    #[test]
    #[ignore = "requires an explicitly authorized remote CUDA run"]
    fn step_inputs_keep_private_values_after_reader_retirement_and_current_bank_reuse() {
        let (provider, domain) = publication_test_provider();
        let mut session = publication_test_session(Arc::clone(&provider), &domain);
        session
            .bind_parent(publication_test_parent(&provider))
            .unwrap();
        let mut lease = session.acquire().unwrap();
        let context = session.published_model_context(&lease, 1).unwrap();
        let cache = session
            .published_tensor(&lease, SemanticStateRole::from_code(8).unwrap(), 0, 1)
            .unwrap();
        let inputs = Arc::clone(session.steps[&lease.token].inputs.as_ref().unwrap());
        let mut feedback_before = Vec::new();
        for (&(role, index), view) in inputs
            .views
            .first()
            .expect("two publication input banks")
            .iter()
            .filter(|(key, _)| matches!(key.0, 15..=17))
        {
            feedback_before.push((
                (role, index),
                session.publication_read(view.clone()).unwrap(),
            ));
        }
        assert_eq!(feedback_before.len(), 4);
        drop(inputs);
        let source_pointer = context.source.as_ptr();
        let cache_pointer = cache.as_ptr();
        let source_address = unsafe { (*source_pointer).dl_tensor.data as u64 };
        let cache_address = unsafe { (*cache_pointer).dl_tensor.data as u64 };
        let storage = Arc::clone(session.publication.as_ref().unwrap());
        assert!(!storage
            .banks
            .iter()
            .any(|bank| source_address >= bank.device_ptr_value()
                && source_address < bank.device_ptr_value() + size_of::<PublicationBank>() as u64));
        assert!(!storage
            .allocations
            .iter()
            .any(|allocation| cache_address >= allocation.device_ptr_value()
                && cache_address < allocation.device_ptr_value() + allocation.len() as u64));
        let again = session.published_source(&lease, 1).unwrap();
        assert_eq!(
            unsafe { (*again.as_ptr()).dl_tensor.data as u64 },
            source_address
        );
        let source_layout = SemanticTensorLayout {
            role: 0,
            index: 0,
            scalar_type: 3,
            element_bytes: 8,
            rank: 2,
            logical_axis: u64::MAX,
            dimensions: [32, 8, 0, 0],
            strides_bytes: [64, 8, 0, 0],
        };
        let source_input = |tensor| SemanticTensorInput {
            layout: source_layout,
            logical_begin: 0,
            logical_end: 0,
            tensor,
            native_allocation: None,
        };
        let original_source = source_input(session.published_source(&lease, 1).unwrap());
        let original_cache = publication_test_alias(
            &mut session,
            &lease,
            SemanticStateRole::from_code(8).unwrap(),
            1,
        );
        let later_source = source_input(session.published_source(&lease, 1).unwrap());
        let later_cache = publication_test_alias(
            &mut session,
            &lease,
            SemanticStateRole::from_code(8).unwrap(),
            1,
        );
        let witness = session
            .capture_tensor_content(&lease, vec![original_source, original_cache], 1)
            .unwrap();
        let TensorContentSeals::Captured(origins) =
            &session.steps[&lease.token].content[witness.index].seals
        else {
            panic!("native input origins");
        };
        assert!(
            origins
                .iter()
                .all(|origin| matches!(origin, CapturedTensorDigest::Publication(_))),
            "capture must retain the original native input seals"
        );
        session
            .guard_published_content(&lease, &[(SemanticStateRole::from_code(8).unwrap(), 0)], 1)
            .unwrap();
        publication_test_recompute(&mut session, &lease, &provider);
        session.release_published_reader(&mut lease, &[1]).unwrap();
        for _ in 0..2 {
            let mut current = session.acquire().unwrap();
            let current_context = session.published_model_context(&current, 1).unwrap();
            let inputs = Arc::clone(session.steps[&current.token].inputs.as_ref().unwrap());
            let copied_header = session.publication_read(inputs.header.view()).unwrap()[0];
            assert_eq!(copied_header.publication_word, current.identity.word);
            assert_ne!(
                unsafe { (*current_context.source.as_ptr()).dl_tensor.data as u64 },
                source_address
            );
            drop(current_context);
            publication_test_recompute(&mut session, &current, &provider);
            session.release(&mut current, &[1]).unwrap();
        }
        let inputs = Arc::clone(session.steps[&lease.token].inputs.as_ref().unwrap());
        assert_eq!(
            session.publication_read(inputs.header.view()).unwrap()[0].publication_word,
            lease.identity.word
        );
        for (key, bytes) in feedback_before {
            assert_eq!(session.publication_read(inputs.views[0][&key].clone()).unwrap(), bytes,
                "raw feedback and its original statements/provenance must survive physical bank reuse");
        }
        let before = session.host_io_stats();
        session
            .verify_tensor_content(&lease, &witness, vec![later_source, later_cache], 1)
            .unwrap();
        assert_eq!(session.host_io_stats(), before);
        drop(witness);
        assert!(session.release(&mut lease, &[1]).is_err());
        drop(context);
        drop(cache);
        drop(again);
        drop(storage);
        drop(inputs);
        session.release(&mut lease, &[1]).unwrap();
        drop(session);
        provider.memory().reap_pending_deallocations().unwrap();
        assert_eq!(provider.memory().allocated_bytes(), 0);
    }

    #[test]
    fn model_context_joins_exact_acquired_header_prefix_and_ring() {
        let identity = |byte| Identity256::from_bytes([byte; 32]);
        let mut lease = SemanticPublishedLease {
            issuer: Arc::new(()),
            token: 7,
            active: true,
            identity: SemanticPublishedIdentity {
                instance: identity(1),
                word: 12,
                logical_digest: identity(2),
                state_digest: identity(3),
            },
            header: PublicationHeader {
                abi: 1,
                instance: identity(1),
                publication_word: 12,
                sealed_epoch: 6,
                logical_digest: identity(2),
                state_digest: identity(3),
                descriptor_digest: identity(4),
                semantic_owner: 5,
                semantic_slot: 6,
                semantic_generation: 7,
                semantic_digest: identity(8),
                semantic_extents: [9, 10, 11],
                prefix_extent: 2,
                ring_head: 17,
                model_generation: 12,
                neural_bank: 1,
                neural_generation: 13,
                cache_generation: 14,
                authority_generation: 15,
                ..PublicationHeader::default()
            },
            source: source_rows(),
            directory: Vec::new(),
        };
        let context = lease.model_context_header().unwrap();
        assert_eq!(context.descriptor_digest, identity(4));
        assert_eq!(
            (
                context.semantic_owner,
                context.semantic_slot,
                context.semantic_generation,
                context.semantic_digest,
                context.semantic_extents
            ),
            (5, 6, 7, identity(8), [9, 10, 11])
        );
        assert_eq!(context.ring_head, 17);
        assert_eq!(context.prefix_extent, 2);
        assert_eq!(
            (
                context.model_generation,
                context.neural_bank,
                context.neural_generation,
                context.cache_generation,
                context.authority_generation
            ),
            (12, 1, 13, 14, 15)
        );
        lease.header.state_digest = identity(19);
        assert!(lease.model_context_header().is_err());
    }

    #[test]
    fn publication_bank_views_use_original_fields_and_slot_order() {
        let header = PublicationHeader {
            prefix_extent: 23,
            ring_head: 17,
            ..PublicationHeader::default()
        };
        let source = source_rows();
        let mut bytes = publication_abi_bytes(&[header]);
        bytes.extend(publication_abi_bytes(&source));
        let (range, shape, strides) = PublicationBankField::Source.layout();
        assert_eq!(range.start, std::mem::offset_of!(PublicationBank, source));
        assert_eq!(range.len(), size_of::<[SourceSlot; 32]>());
        assert_eq!((shape, strides), (vec![32, 8], vec![8, 1]));
        assert_eq!(&bytes[range], publication_abi_bytes(&source));
        for (field, value) in [
            (PublicationBankField::PrefixExtent, 23u64),
            (PublicationBankField::RingHead, 17u64),
        ] {
            let (range, shape, strides) = field.layout();
            assert_eq!(range.start % size_of::<u64>(), 0);
            assert_eq!(range.len(), size_of::<u64>());
            assert_eq!((shape, strides), (vec![1], vec![1]));
            assert_eq!(&bytes[range], value.to_ne_bytes());
        }
    }

    #[test]
    fn active_row_table_requires_independent_publication_banks() {
        assert!(publication_mutable_role(
            SemanticStateRole::TensorLayout as u64
        ));
    }

    #[test]
    fn active_text_rows_include_the_reserved_window_before_feedback_positions() {
        for position in [63, 64, 95, 96] {
            let mut source = [SourceSlot::default(); 32];
            source[7] = SourceSlot {
                token: MASK_TOKEN as u64,
                logical_position: position,
                kind: 2,
                valid: 1,
                ..SourceSlot::default()
            };
            let admitted = validate_text_parent(&source, 0, 64, 2, 262144, 0, 0);
            assert_eq!(admitted.is_ok(), position < 96);
        }
    }

    #[test]
    fn active_table_keeps_computed_empty_distinct_from_uncomputed() {
        let layouts = [SemanticTensorLayout {
            role: 51,
            rank: 4,
            logical_axis: 2,
            element_bytes: 2,
            scalar_type: 4,
            dimensions: [1, 2, 35, 4],
            strides_bytes: [560, 280, 8, 2],
            ..SemanticTensorLayout::default()
        }];
        let cold = tensor_table_bytes(&layouts, false, &[]).unwrap();
        let empty = tensor_table_bytes(&layouts, true, &[]).unwrap();
        assert_ne!(cold, empty);
        assert_eq!(
            decode_tensor_table(&cold).unwrap().2,
            SemanticActiveRows {
                computed: false,
                rows: vec![]
            }
        );
        assert_eq!(
            decode_tensor_table(&empty).unwrap().2,
            SemanticActiveRows {
                computed: true,
                rows: vec![]
            }
        );
        assert_eq!(decode_tensor_table(&empty).unwrap().1, layouts);
        assert!(decode_tensor_table(&publication_abi_bytes(&layouts)).is_err());
        let mut invalid = empty.clone();
        invalid[16..24].copy_from_slice(&2u64.to_ne_bytes());
        assert!(decode_tensor_table(&invalid).is_err());
        invalid = empty.clone();
        invalid[24..32].copy_from_slice(&1u64.to_ne_bytes());
        assert!(decode_tensor_table(&invalid).is_err());
        assert!(decode_tensor_table(&empty[..empty.len() - 1]).is_err());
        let row = SemanticActiveRow {
            physical_row: 0,
            source_slot: 0,
            logical_position: 0,
            kind: 2,
        };
        assert!(tensor_table_bytes(&layouts, false, &[row]).is_err());
        assert!(tensor_table_capacity(usize::MAX, 35).is_err());
    }

    #[test]
    fn active_tensor_geometry_preserves_full_physical_capacity() {
        let producer = SemanticTensorLayout {
            role: 51,
            rank: 4,
            logical_axis: 2,
            element_bytes: 2,
            scalar_type: 4,
            dimensions: [1, 2, 35, 4],
            strides_bytes: [560, 2, 16, 4],
            ..SemanticTensorLayout::default()
        };
        let cold = canonical_tensor_layout(producer).unwrap();
        assert!(validate_active_capacity(&cold, 35).is_ok());
        assert!(validate_active_capacity(&cold, 34).is_err());
        let pending = continuation_tensor_layout(&producer, 0, 35, &cold).unwrap();
        assert_eq!(pending.dimensions, producer.dimensions);
        assert_eq!(pending.strides_bytes, [560, 280, 8, 2]);
        assert!(tensor_copy_plan(&producer, &pending).is_ok());
        assert!(continuation_tensor_layout(&producer, 8, 9, &cold).is_err());
        assert!(continuation_tensor_layout(&producer, 0, 3, &cold).is_err());
        let linear = SemanticTensorLayout {
            role: 53,
            rank: 3,
            logical_axis: 0,
            element_bytes: 4,
            scalar_type: 6,
            dimensions: [35, 4, 2, 0],
            strides_bytes: [32, 8, 4, 0],
            ..SemanticTensorLayout::default()
        };
        assert!(validate_active_capacity(&linear, 35).is_ok());
        assert!(validate_active_capacity(
            &SemanticTensorLayout {
                logical_axis: u64::MAX,
                ..linear
            },
            35
        )
        .is_err());
    }

    #[test]
    fn publication_rng_binding_uses_only_the_actual_header_coordinates() {
        let header = PublicationHeader {
            model_generation: 17,
            family_id: 29,
            stream_serial: (1u64 << 56) - 1,
            proposal: u64::from(u32::MAX),
            ..PublicationHeader::default()
        };
        assert_eq!(
            header.rng_binding().unwrap(),
            SemanticRngBinding {
                model_generation: 17,
                family_id: 29,
                stream_serial: (1u64 << 56) - 1,
                proposal: u32::MAX,
            }
        );
        for invalid in [
            PublicationHeader {
                model_generation: 1u64 << 32,
                ..header
            },
            PublicationHeader {
                family_id: 256,
                ..header
            },
            PublicationHeader {
                stream_serial: 1u64 << 56,
                ..header
            },
            PublicationHeader {
                proposal: 1u64 << 32,
                ..header
            },
        ] {
            assert!(invalid.rng_binding().is_err());
        }
    }

    #[test]
    fn cold_continuation_layouts_match_original_fixed_output_snapshots() {
        let prefix = canonical_tensor_layout(SemanticTensorLayout {
            role: 4,
            rank: 4,
            logical_axis: 2,
            element_bytes: 2,
            scalar_type: 4,
            dimensions: [1, 2, 128, 4],
            ..SemanticTensorLayout::default()
        })
        .unwrap();
        let active = canonical_tensor_layout(SemanticTensorLayout {
            role: 51,
            rank: 4,
            logical_axis: 2,
            element_bytes: 2,
            scalar_type: 4,
            dimensions: [1, 2, 35, 4],
            ..SemanticTensorLayout::default()
        })
        .unwrap();
        let state = canonical_tensor_layout(SemanticTensorLayout {
            role: 6,
            rank: 2,
            logical_axis: u64::MAX,
            element_bytes: 4,
            scalar_type: 6,
            dimensions: [4, 128, 0, 0],
            ..SemanticTensorLayout::default()
        })
        .unwrap();
        let mut layouts = Vec::new();
        for (model, extent) in [(prefix, 32), (active, 35), (state, 0)] {
            let cold = continuation_capacity_layout(model).unwrap();
            let mut producer = cold;
            if model.role != 6 {
                // The original can be transposed; only the owned destination
                // has the immutable canonical transport strides.
                producer.strides_bytes = [extent * 16, 2, 16, 4];
            }
            assert_eq!(
                continuation_tensor_layout(&producer, 0, extent, &model).unwrap(),
                cold
            );
            assert!(tensor_copy_plan(&producer, &cold).is_ok());
            layouts.push(cold);
        }
        assert_eq!(layouts[0].dimensions, [1, 2, 32, 4]);
        assert_eq!(layouts[1], active);
        assert_eq!(layouts[2], state);
        let table = tensor_table_bytes(&layouts, true, &[]).unwrap();
        let (_, decoded, rows) = decode_tensor_table(&table).unwrap();
        assert_eq!(decoded, layouts);
        assert_eq!(
            rows,
            SemanticActiveRows {
                computed: true,
                rows: vec![]
            }
        );
        assert!(continuation_capacity_layout(SemanticTensorLayout { role: 3, ..state }).is_err());
        assert!(continuation_capacity_layout(SemanticTensorLayout {
            logical_axis: 1,
            ..active
        })
        .is_err());
    }

    #[test]
    fn continuation_services_preserve_original_device_roster_and_capacity() {
        let layouts = continuation_service_layouts(9, 66, None).unwrap();
        let expected = [
            (3, 8, [32, 2, 0, 0]),
            (3, 8, [1, 0, 0, 0]),
            (8, 1, [32, 0, 0, 0]),
            (3, 8, [66, 4, 0, 0]),
            (3, 8, [1, 0, 0, 0]),
            (8, 1, [1, 0, 0, 0]),
        ];
        for (ordinal, (layout, (scalar_type, element_bytes, dimensions))) in
            layouts.iter().zip(expected).enumerate()
        {
            assert_eq!((layout.role, layout.index), (0, 9 + ordinal as u64));
            assert_eq!(
                (layout.scalar_type, layout.element_bytes, layout.dimensions),
                (scalar_type, element_bytes, dimensions)
            );
            assert_eq!(layout.logical_axis, u64::MAX);
            let bytes = tensor_layout_bytes(layout).unwrap();
            let range = tensor_content_range(layout, 0, 0, bytes).unwrap();
            assert_eq!(range.index, layout.index);
        }
        assert!(continuation_service_layouts(usize::MAX, 66, None).is_err());
        assert!(continuation_service_layouts(0, 0, None).is_err());
        let proposal = continuation_service_layouts(9, 66, Some(2)).unwrap();
        assert_eq!(proposal.len(), 7);
        assert_eq!(proposal[6].index, 15);
        assert_eq!(proposal[6].scalar_type, 9);
        assert_eq!(proposal[6].element_bytes, 8);
        assert_eq!(proposal[6].dimensions, [2, 2, 3, 0]);
        assert_eq!(tensor_layout_bytes(&proposal[6]).unwrap(), 96);
    }

    #[test]
    fn block_roster_comes_from_the_original_model_contract_schema() {
        let schema = br#"{"counter_encoding":"u32-hex8","model":{"physical":{"head":{"kind":"parameter"},"state":{"kind":"buffer"},"trunk":{"kind":"parameter"}}}}"#;
        let mut record = vec![0u8; 104];
        record.extend_from_slice(schema);
        let layout = SemanticModelContractLayout {
            schema_begin: 104,
            schema_bytes: schema.len() as u64,
            schema_digest_offset: 0,
            generation_offset: 32,
            numerical_digest_offset: 40,
            identity_offset: 72,
        };
        assert_eq!(
            model_physical_parameter_roster(&record, layout).unwrap(),
            Some(vec!["head".into(), "trunk".into()])
        );
        let mut invalid = record;
        let location = invalid
            .windows(6)
            .position(|window| window == b"buffer")
            .unwrap();
        invalid[location..location + 6].copy_from_slice(b"broken");
        assert!(model_physical_parameter_roster(&invalid, layout).is_err());
    }

    #[test]
    fn continuation_transport_does_not_rebase_original_suffix_or_nonpositional_outputs() {
        let suffix = canonical_tensor_layout(SemanticTensorLayout {
            role: 4,
            rank: 4,
            logical_axis: 2,
            element_bytes: 2,
            scalar_type: 4,
            dimensions: [1, 2, 32, 4],
            ..SemanticTensorLayout::default()
        })
        .unwrap();
        let cold = prefix_capacity_layout(
            SemanticTensorLayout {
                dimensions: [1, 2, 0, 4],
                ..suffix
            },
            16,
        )
        .unwrap();
        for (prefix, end) in [(0, 0), (3, 5), (16, 16)] {
            let pending = continuation_tensor_layout(&suffix, 0, 32, &cold).unwrap();
            assert_eq!(pending, suffix);
            assert!(continuation_tensor_layout(&suffix, prefix, end, &cold).is_err());
        }
        let state = canonical_tensor_layout(SemanticTensorLayout {
            role: 6,
            rank: 2,
            logical_axis: u64::MAX,
            element_bytes: 4,
            scalar_type: 6,
            dimensions: [4, 128, 0, 0],
            ..SemanticTensorLayout::default()
        })
        .unwrap();
        assert_eq!(
            continuation_tensor_layout(&state, 0, 0, &state).unwrap(),
            state
        );
        assert!(continuation_tensor_layout(&state, 3, 5, &state).is_err());
    }

    #[test]
    fn cold_intent_owner_constructs_an_empty_queue_with_the_actual_effect() {
        let effect = b"deliver the committed token sequence to the request output";
        let records = initial_intent_records(effect, 2, 4096, 1024).unwrap();
        assert_eq!(records[0].role, SemanticStateRole::IntentEntries);
        assert_eq!(records[0].bytes.len(), size_of::<IntentQueueHeader>());
        assert_eq!(
            records[0].capacity_bytes,
            size_of::<IntentQueueHeader>() + 2 * size_of::<IntentEntry>()
        );
        // SAFETY: the production builder returned a complete padding-free header.
        let header = unsafe {
            records[0]
                .bytes
                .as_ptr()
                .cast::<IntentQueueHeader>()
                .read_unaligned()
        };
        assert_eq!((header.abi, header.count, header.capacity), (1, 0, 2));
        assert_eq!(header.chain_head, Identity256::default());
        assert_eq!(
            (header.effect_offset_bytes, header.effect_length_bytes),
            (0, effect.len() as u64)
        );
        assert_eq!(header.payload_used_bytes, effect.len() as u64);
        assert_eq!(header.payload_capacity_bytes, 4096);
        assert_eq!(records[1].role, SemanticStateRole::IntentPayload);
        assert_eq!(records[1].bytes, effect);
        assert_eq!(records[1].capacity_bytes, 4096);
        assert!(initial_intent_records(&[], 2, 4096, 1024).is_err());
        assert!(initial_intent_records(effect, 0, 4096, 1024).is_err());
        assert!(initial_intent_records(effect, u64::MAX, 4096, 1024).is_err());
        assert!(initial_intent_records(effect, 2, effect.len() + 1023, 1024).is_err());
    }

    #[test]
    fn checkpoint_intent_projection_rechecks_the_native_key_and_chain() {
        let effect = b"record result";
        let output = 1u64.to_le_bytes();
        let mut material = publication_material_sample();
        let mut entry = IntentEntry {
            checkpoint_lineage: Identity256::from_bytes([1; 32]),
            base_logical: Identity256::from_bytes([2; 32]),
            effective_delta: Identity256::from_bytes([3; 32]),
            result_logical: Identity256::from_bytes([4; 32]),
            effect_digest: Identity256::from_bytes(Sha256::digest(effect).into()),
            payload_digest: Identity256::from_bytes(Sha256::digest(output).into()),
            payload_offset: effect.len() as u64,
            payload_len: output.len() as u64,
            ..IntentEntry::default()
        };
        let mut key = Sha256::new();
        key.update(0x786c6f67696e7431u64.to_le_bytes());
        for part in [
            entry.checkpoint_lineage,
            entry.base_logical,
            entry.effective_delta,
            entry.result_logical,
            entry.effect_digest,
            entry.payload_digest,
        ] {
            key.update(part.as_bytes());
        }
        entry.stable_identity = Identity256::from_bytes(key.finalize().into());
        entry.chain = publication_fold_digest(Identity256::default(), 30, 0, entry.stable_identity);
        let header = IntentQueueHeader {
            abi: 1,
            count: 1,
            capacity: 2,
            payload_used_bytes: (effect.len() + output.len()) as u64,
            payload_capacity_bytes: 64,
            effect_offset_bytes: 0,
            effect_length_bytes: effect.len() as u64,
            chain_head: entry.chain,
        };
        for range in &mut material.ranges {
            match range.range.role {
                30 => {
                    range.bytes = publication_abi_bytes(&[header]);
                    range.bytes.extend(publication_abi_bytes(&[entry]));
                    range.capacity = size_of::<IntentQueueHeader>() + 2 * size_of::<IntentEntry>();
                }
                31 => {
                    range.bytes = [effect.as_slice(), output.as_slice()].concat();
                    range.capacity = 64;
                }
                _ => continue,
            }
            range.range.length_bytes = range.bytes.len() as u64;
            range.range.digest = range.original_record_digest();
        }
        publication_material_sample_runtime(&mut material);
        material.bank.header.descriptor_digest = material.original_descriptor_digest();
        let encoded = material.encode().unwrap();
        let projected = output_intents_from_publication_material(&encoded).unwrap();
        assert_eq!(projected.len(), 1);
        assert_eq!(projected[0].stable_identity, entry.stable_identity);
        assert_eq!(projected[0].effect, effect);
        assert_eq!(projected[0].payload, output);

        let entry_range = material
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 30)
            .unwrap();
        let last = entry_range.bytes.last_mut().unwrap();
        *last ^= 1;
        entry_range.range.digest = entry_range.original_record_digest();
        material.bank.header.descriptor_digest = material.original_descriptor_digest();
        assert!(output_intents_from_publication_material(&material.encode().unwrap()).is_err());
    }

    #[test]
    fn semantic_tensor_admission_preserves_original_type_strides_and_bounds() {
        let layout = SemanticTensorLayout {
            role: SemanticStateRole::AttentionKeys as u64,
            index: 0,
            element_bytes: 2,
            scalar_type: 4,
            rank: 4,
            logical_axis: 2,
            dimensions: [1, 2, 3, 4],
            strides_bytes: [48, 24, 8, 2],
        };
        let metadata = TensorMetadata {
            device_type: crate::dlpack::K_DLCUDA,
            device_id: 0,
            dtype: crate::dlpack::DLDataType {
                code: 2,
                bits: 16,
                lanes: 1,
            },
            shape: &[1, 2, 3, 4],
            strides: None,
            data: 0x1000,
            byte_offset: 2,
        };
        assert_eq!(
            validate_tensor_metadata(&layout, &metadata, 0).unwrap(),
            (0x1002, 48)
        );
        let mut wrong = metadata;
        wrong.dtype.code = 4; // BF16 is not F16 despite equal element width.
        assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
        wrong = metadata;
        wrong.strides = Some(&[0, 0, 0, 0]);
        assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
        wrong = metadata;
        wrong.device_id = 1;
        assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
        wrong = metadata;
        wrong.data = u64::MAX - 1;
        assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
        wrong = metadata;
        wrong.byte_offset = 1;
        assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
        let mut transposed = layout;
        transposed.strides_bytes = [48, 2, 16, 4];
        let mut strided = metadata;
        strided.strides = Some(&[24, 1, 8, 2]);
        assert_eq!(
            validate_tensor_metadata(&transposed, &strided, 0).unwrap(),
            (0x1002, 48)
        );
        let mut empty = layout;
        empty.dimensions[2] = 0;
        empty.strides_bytes = [0, 0, 8, 2];
        let mut empty_metadata = metadata;
        empty_metadata.shape = &[1, 2, 0, 4];
        empty_metadata.data = 0;
        empty_metadata.byte_offset = 0;
        assert_eq!(
            validate_tensor_metadata(&empty, &empty_metadata, 0).unwrap(),
            (0, 0)
        );
    }

    #[test]
    fn semantic_tensor_scalar_keeps_one_cell_and_original_rank() {
        for (scalar_type, element_bytes, code) in [
            (1, 1, 1),
            (2, 4, 1),
            (3, 8, 1),
            (4, 2, 2),
            (5, 2, 4),
            (6, 4, 2),
            (7, 8, 0),
            (8, 1, 6),
            (9, 8, 2),
        ] {
            let layout = SemanticTensorLayout {
                role: 18,
                index: 0,
                scalar_type,
                element_bytes,
                rank: 0,
                logical_axis: u64::MAX,
                dimensions: [0; 4],
                strides_bytes: [0; 4],
            };
            let metadata = TensorMetadata {
                device_type: crate::dlpack::K_DLCUDA,
                device_id: 0,
                dtype: crate::dlpack::DLDataType {
                    code,
                    bits: (element_bytes * 8) as u8,
                    lanes: 1,
                },
                shape: &[],
                strides: None,
                data: 4096,
                byte_offset: element_bytes,
            };
            assert_eq!(
                validate_tensor_metadata(&layout, &metadata, 0).unwrap(),
                (4096 + element_bytes, element_bytes as usize)
            );
            assert_eq!(
                tensor_layout_bytes(&layout).unwrap(),
                element_bytes as usize
            );
            assert_eq!(canonical_tensor_layout(layout).unwrap(), layout);
            assert_eq!(
                tensor_copy_plan(&layout, &layout).unwrap(),
                vec![(0, 0, element_bytes as usize)]
            );
            let mut wrong = metadata;
            wrong.data = 0;
            assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
            wrong = metadata;
            wrong.shape = &[1];
            assert!(validate_tensor_metadata(&layout, &wrong, 0).is_err());
            let mut malformed = layout;
            malformed.logical_axis = 0;
            assert!(tensor_layout_bytes(&malformed).is_err());
            malformed = layout;
            malformed.dimensions[0] = 1;
            assert!(tensor_layout_bytes(&malformed).is_err());
            malformed = layout;
            malformed.strides_bytes[0] = element_bytes;
            assert!(tensor_layout_bytes(&malformed).is_err());
        }
    }

    #[test]
    fn publication_material_scalar_layout_survives_cold_codec() {
        let mut material = publication_material_sample();
        let layout = material.layouts.get_mut(&(18, 0)).unwrap();
        layout.rank = 0;
        layout.dimensions = [0; 4];
        layout.strides_bytes = [0; 4];
        let scalar = *layout;
        let table = material
            .ranges
            .iter_mut()
            .find(|item| item.range.role == 55)
            .unwrap();
        table.bytes = tensor_table_bytes(
            &material.layouts.values().copied().collect::<Vec<_>>(),
            false,
            &[],
        )
        .unwrap();
        table.range.digest = table.original_record_digest();
        publication_material_sample_runtime(&mut material);
        material.bank.header.descriptor_digest = material.original_descriptor_digest();
        let encoded = material.encode().unwrap();
        let restored = PublicationMaterial::decode(&encoded).unwrap();
        assert_eq!(restored.layouts[&(18, 0)], scalar);
        let original = material
            .ranges
            .iter()
            .find(|item| item.range.role == 18)
            .unwrap();
        let actual = restored
            .ranges
            .iter()
            .find(|item| item.range.role == 18)
            .unwrap();
        assert_eq!(actual.bytes, original.bytes);
        assert_eq!(actual.bytes.len(), scalar.element_bytes as usize);
        assert_eq!(restored.encode().unwrap(), encoded);
    }

    #[test]
    fn semantic_tensor_scalar_metadata_allows_null_zero_rank_arrays() {
        // Only the importer's metadata boundary runs here, not a device import.
        let mut value = 3.5f32;
        let mut descriptor = crate::dlpack::DLTensor {
            data: (&mut value as *mut f32).cast(),
            device: crate::dlpack::DLDevice {
                device_type: crate::dlpack::K_DLCUDA,
                device_id: 0,
            },
            ndim: 0,
            dtype: crate::dlpack::DLDataType {
                code: 2,
                bits: 32,
                lanes: 1,
            },
            shape: std::ptr::null_mut(),
            strides: std::ptr::null_mut(),
            byte_offset: 0,
        };
        let layout = SemanticTensorLayout {
            role: 18,
            index: 0,
            element_bytes: 4,
            scalar_type: 6,
            rank: 0,
            logical_axis: u64::MAX,
            dimensions: [0; 4],
            strides_bytes: [0; 4],
        };
        // SAFETY: zero-rank metadata has no array entries to dereference.
        let actual = unsafe { semantic_tensor_metadata(&descriptor) }.unwrap();
        assert!(actual.shape.is_empty());
        assert!(actual.strides.is_none());
        assert_eq!(
            validate_tensor_metadata(&layout, &actual, 0).unwrap(),
            ((&value as *const f32) as usize as u64, size_of::<f32>())
        );
        for ndim in [-1, 1, 4, 5] {
            descriptor.ndim = ndim;
            // SAFETY: invalid rank/null shape is rejected before any array read.
            assert!(unsafe { semantic_tensor_metadata(&descriptor) }.is_err());
        }
    }

    #[test]
    fn publication_material_empty_model_buffer_keeps_zero_capacity() {
        for role in 18..=20 {
            let mut material = publication_material_sample();
            let layout = material.layouts.get_mut(&(role, 0)).unwrap();
            layout.rank = 3;
            layout.dimensions = [2, 0, 3, 0];
            layout.strides_bytes = [12, 12, 4, 0];
            let empty = *layout;
            let buffer = material
                .ranges
                .iter_mut()
                .find(|item| item.range.role == role)
                .unwrap();
            buffer.bytes.clear();
            buffer.capacity = 0;
            buffer.range.length_bytes = 0;
            let (allocation, offset) = material.model_memory.location(role, 0).unwrap();
            assert_eq!(offset, 0);
            material.model_allocations[allocation].clear();
            material.model_memory.allocation_bytes[allocation] = 0;
            material
                .model_memory
                .storages
                .iter_mut()
                .find(|storage| storage.allocation == allocation as u64)
                .unwrap()
                .span_bytes = 0;
            buffer.range.backing_digest = Identity256::from_bytes(Sha256::digest(b"").into());
            let table = material
                .ranges
                .iter_mut()
                .find(|item| item.range.role == 55)
                .unwrap();
            table.bytes = tensor_table_bytes(
                &material.layouts.values().copied().collect::<Vec<_>>(),
                false,
                &[],
            )
            .unwrap();
            table.range.digest = table.original_record_digest();
            publication_material_sample_runtime(&mut material);
            material.bank.header.descriptor_digest = material.original_descriptor_digest();
            let encoded = material.encode().unwrap();
            let restored = PublicationMaterial::decode(&encoded).unwrap();
            assert_eq!(restored.layouts[&(role, 0)], empty);
            let actual = restored
                .ranges
                .iter()
                .find(|item| item.range.role == role)
                .unwrap();
            assert!(actual.bytes.is_empty());
            assert_eq!(actual.capacity, 0);
            assert_eq!(tensor_layout_bytes(&empty).unwrap(), 0);
            assert!(tensor_copy_plan(&empty, &empty).unwrap().is_empty());
            assert_eq!(restored.encode().unwrap(), encoded);
            for (capacity, begin, end) in [(1, 0, 0), (0, 1, 1), (0, 0, 1)] {
                let buffer = material
                    .ranges
                    .iter_mut()
                    .find(|item| item.range.role == role)
                    .unwrap();
                buffer.capacity = capacity;
                buffer.range.logical_begin = begin;
                buffer.range.logical_end = end;
                publication_material_sample_runtime(&mut material);
                material.bank.header.descriptor_digest = material.original_descriptor_digest();
                assert!(
                    material.encode().is_err(),
                    "empty buffer accepted a fictitious capacity or interval"
                );
            }
            let buffer = material
                .ranges
                .iter_mut()
                .find(|item| item.range.role == role)
                .unwrap();
            buffer.capacity = 0;
            buffer.range.logical_begin = 0;
            buffer.range.logical_end = 0;
            publication_material_sample_runtime(&mut material);
            material.bank.header.descriptor_digest = material.original_descriptor_digest();
            material.layouts.get_mut(&(role, 0)).unwrap().dimensions[1] = 1;
            assert!(
                material.encode().is_err(),
                "nonempty model cells acquired zero capacity"
            );
        }
    }

    #[test]
    fn feedback_payload_preserves_qualifiers_without_service_headers() {
        use crate::semantic_hypergraph::SemanticRecordEncoding;
        use crate::SemanticTypedRecord;
        use xlog_core::RelId;

        let atom = |header: u8, value: u32| {
            let mut bytes = vec![header; 55];
            bytes.extend_from_slice(&17u32.to_le_bytes());
            bytes.extend_from_slice(&1u32.to_le_bytes());
            let start = bytes.len();
            bytes.push(1); // Canonical U32 argument tag.
            bytes.extend_from_slice(&value.to_le_bytes());
            let end = bytes.len();
            SemanticRecordEncoding {
                bytes,
                arguments: std::iter::once(start..end).collect(),
            }
        };
        let record = |qualifiers| SemanticTypedRecord {
            predicate: RelId(17),
            arguments: vec![crate::SemanticArgument::U32(1)],
            qualifiers,
        };
        let records = SemanticAdmissionRecords {
            predicates: vec![],
            records: vec![record(vec![1, 2]), record(vec![]), record(vec![])],
            supports: vec![],
        };
        let encoded = vec![atom(0xA5, 1), atom(0xA5, 2), atom(0xA5, 3)];
        let payload = feedback_statement_payload(&records, &encoded, 0).unwrap();
        let changed_headers = vec![atom(0x5A, 1), atom(0x5A, 2), atom(0x5A, 3)];
        assert_eq!(
            payload,
            feedback_statement_payload(&records, &changed_headers, 0).unwrap()
        );
        assert_eq!(&payload[..8], &13u64.to_le_bytes());
        assert_eq!(&payload[8..12], &17u32.to_le_bytes());
        assert_eq!(&payload[21..25], &2u32.to_le_bytes());
        let changed_values = vec![atom(0xA5, 1), atom(0xA5, 9), atom(0xA5, 3)];
        assert_ne!(
            payload,
            feedback_statement_payload(&records, &changed_values, 0).unwrap()
        );
        let mut reordered = records;
        reordered.records[0].qualifiers.reverse();
        assert_ne!(
            payload,
            feedback_statement_payload(&reordered, &encoded, 0).unwrap()
        );
    }

    #[test]
    fn publication_tensor_layout_keeps_dtype_distinct_from_byte_width() {
        assert_eq!(size_of::<SemanticTensorLayout>(), 112);
    }

    fn source_rows() -> [SourceSlot; 32] {
        let mut rows = [SourceSlot::default(); 32];
        // Source slots deliberately differ from logical and packed row order.
        rows[5] = SourceSlot {
            token: 40,
            logical_position: 0,
            kind: 1,
            provenance: 1,
            valid: 1,
            committed: 0,
            recomputed: 0,
            provenance_record: 0,
        };
        rows[1] = SourceSlot {
            token: MASK_TOKEN as u64,
            logical_position: 1,
            kind: 2,
            provenance: 0,
            valid: 1,
            committed: 0,
            recomputed: 0,
            provenance_record: 0,
        };
        rows[12] = SourceSlot {
            token: 42,
            logical_position: 2,
            kind: 1,
            provenance: 2,
            valid: 1,
            committed: 0,
            recomputed: 0,
            provenance_record: 2,
        };
        rows
    }

    #[test]
    fn initial_source_ledger_derives_tokens_and_private_provenance_without_changing_geometry() {
        let mut ring = [SourceSlot::default(); 32];
        ring[7] = SourceSlot {
            token: 41,
            logical_position: 3,
            kind: 1,
            provenance: 1,
            valid: 1,
            ..SourceSlot::default()
        };
        ring[2] = SourceSlot {
            token: MASK_TOKEN as u64,
            logical_position: 4,
            kind: 2,
            valid: 1,
            ..SourceSlot::default()
        };
        let prefix = vec![SourceSlot {
            token: 40,
            logical_position: 0,
            kind: 1,
            provenance: 1,
            valid: 1,
            committed: 1,
            ..SourceSlot::default()
        }];
        let sources = [SemanticObservedSource {
            identity: "observation".into(),
            tokens: vec![40, 41],
            origin: b"complete admitted observation and manifest".to_vec(),
        }];
        let mapping = [
            SemanticSourceMapping {
                source: "observation".into(),
                offset: 0,
                logical_position: 0,
            },
            SemanticSourceMapping {
                source: "observation".into(),
                offset: 1,
                logical_position: 3,
            },
        ];
        let (actual, committed, ledger) = initial_source_ledger(
            ring,
            prefix.clone(),
            &sources,
            &mapping,
            b"complete task authority",
            3,
            34,
        )
        .unwrap();
        assert_eq!(
            (
                actual[7].token,
                actual[7].logical_position,
                actual[7].provenance_record
            ),
            (41, 3, 1)
        );
        assert_eq!(committed[0].provenance_record, 0);
        assert_eq!(actual[2].provenance, 0);
        assert_eq!(ledger.bytes.len(), 2 * size_of::<TokenProvenance>());
        assert_eq!(ledger.capacity_bytes, 34 * size_of::<TokenProvenance>());
        // SAFETY: production emitted two complete initialized integral records.
        let record = unsafe {
            ledger
                .bytes
                .as_ptr()
                .add(size_of::<TokenProvenance>())
                .cast::<TokenProvenance>()
                .read_unaligned()
        };
        assert_eq!(
            (
                record.source_slot,
                record.logical_position,
                record.token,
                record.ordinal,
                record.authority_generation
            ),
            (7, 3, 41, 1, 3)
        );
        assert_eq!(record.action_receipt_digest, Identity256::default());
        assert_ne!(record.origin_logical_digest, Identity256::default());
        assert_ne!(record.authority_closure_digest, Identity256::default());
        assert_ne!(record.record_digest, Identity256::default());
        for field in 0..7 {
            let mut changed = ring;
            let mut links = mapping.to_vec();
            match field {
                0 => changed[7].token = 42,
                1 => changed[7].provenance = 2,
                2 => changed[7].provenance_record = 99,
                3 => links[1].offset = 2,
                4 => links[1].logical_position = 4,
                5 => links[1].source = "foreign".into(),
                _ => links[1].logical_position = 0,
            }
            assert!(
                initial_source_ledger(
                    changed,
                    prefix.clone(),
                    &sources,
                    &links,
                    b"complete task authority",
                    3,
                    34
                )
                .is_err(),
                "mutation {field}"
            );
        }
    }

    #[test]
    fn initial_source_layout_preserves_admitted_tokens_across_prefix_and_ring() {
        let sources = [SemanticObservedSource {
            identity: "observation".into(),
            tokens: (0..40).collect(),
            origin: b"complete admitted observation and manifest".to_vec(),
        }];
        let mapping = (0..40)
            .map(|position| SemanticSourceMapping {
                source: "observation".into(),
                offset: position,
                logical_position: position,
            })
            .collect::<Vec<_>>();
        let layout = initial_source_layout(
            &sources,
            &mapping,
            b"complete task authority",
            3,
            72,
            64,
            3,
            262144,
            248000,
        )
        .unwrap();
        assert_eq!(layout.prefill_tokens, (0..8).collect::<Vec<_>>());
        assert_eq!(layout.prefix.len(), 8);
        assert_eq!(layout.prefix[7].token, 7);
        assert_eq!(layout.prefix[7].committed, 1);
        assert_eq!(layout.source[0].token, 8);
        assert_eq!(layout.source[0].logical_position, 8);
        assert_eq!(layout.source[31].token, 39);
        assert_eq!(layout.source[31].logical_position, 39);
        assert_eq!(layout.source[31].committed, 0);
        assert_eq!(layout.ring_head, 0);
        assert_eq!(
            validate_text_parent(&layout.source, 8, 64, 3, 262144, layout.ring_head, 40).unwrap(),
            40
        );
    }

    #[test]
    fn short_admitted_source_needs_no_model_prefill_stage() {
        let sources = [SemanticObservedSource {
            identity: "observation".into(),
            tokens: vec![7, 8],
            origin: b"complete admitted observation".to_vec(),
        }];
        let mapping = (0..2)
            .map(|position| SemanticSourceMapping {
                source: "observation".into(),
                offset: position,
                logical_position: position,
            })
            .collect::<Vec<_>>();
        let layout = initial_source_layout(
            &sources,
            &mapping,
            b"complete task authority",
            1,
            64,
            64,
            2,
            262144,
            248000,
        )
        .unwrap();
        assert!(layout.prefix.is_empty());
        assert!(layout.prefill_tokens.is_empty());
        assert_eq!(layout.source[0].token, 7);
        assert_eq!(layout.source[1].token, 8);
        assert_eq!(layout.ring_head, 2);
        assert_eq!(
            validate_text_parent(&layout.source, 0, 64, 2, 262144, 2, 2).unwrap(),
            2
        );
    }

    #[test]
    fn initial_source_layout_rejects_uncovered_prefix_and_over_capacity() {
        let sources = [SemanticObservedSource {
            identity: "observation".into(),
            tokens: (0..40).collect(),
            origin: b"complete admitted observation and manifest".to_vec(),
        }];
        let mut mapping = (0..40)
            .map(|position| SemanticSourceMapping {
                source: "observation".into(),
                offset: position,
                logical_position: position,
            })
            .collect::<Vec<_>>();
        assert!(initial_source_layout(
            &sources,
            &mapping,
            b"complete task authority",
            3,
            72,
            7,
            3,
            262144,
            248000,
        )
        .is_err());
        assert!(initial_source_layout(
            &sources,
            &mapping,
            b"complete task authority",
            3,
            72,
            8,
            3,
            262144,
            248000,
        )
        .is_err());
        mapping.remove(3);
        assert!(initial_source_layout(
            &sources,
            &mapping,
            b"complete task authority",
            3,
            72,
            64,
            3,
            262144,
            248000,
        )
        .is_err());
    }

    #[test]
    fn initial_prefill_input_requires_the_exact_model_token_tensor_layout() {
        let expected = SemanticTensorLayout {
            role: 0,
            index: 0,
            element_bytes: 8,
            scalar_type: 7,
            rank: 2,
            logical_axis: 1,
            dimensions: [1, 8, 0, 0],
            strides_bytes: [64, 8, 0, 0],
        };
        assert!(validate_initial_prefill_input_layout(&expected, 8).is_ok());
        for changed in [
            SemanticTensorLayout {
                scalar_type: 3,
                ..expected
            },
            SemanticTensorLayout {
                dimensions: [1, 7, 0, 0],
                ..expected
            },
            SemanticTensorLayout {
                dimensions: [2, 8, 0, 0],
                ..expected
            },
            SemanticTensorLayout {
                strides_bytes: [64, 16, 0, 0],
                ..expected
            },
        ] {
            assert!(validate_initial_prefill_input_layout(&changed, 8).is_err());
        }
        assert!(validate_initial_prefill_input_layout(&expected, 0).is_err());
    }

    #[test]
    fn initial_prefill_content_witness_rejects_foreign_or_stale_owners() {
        let issuer = Arc::new(());
        let scope = Arc::new(());
        let identity = Identity256::from_bytes([7; 32]);
        let witness = SemanticInitialPrefillContentWitness {
            issuer: Arc::clone(&issuer),
            scope: Arc::clone(&scope),
            task_identity: identity,
            task_epoch: 3,
            model_generation: 5,
            slot: InitialPrefillContentSlot::Captured(1),
        };
        assert!(witness.matches(&issuer, &scope, identity, 3, 5, 2));
        assert!(!witness.matches(&Arc::new(()), &scope, identity, 3, 5, 2));
        assert!(!witness.matches(&issuer, &Arc::new(()), identity, 3, 5, 2));
        assert!(!witness.matches(&issuer, &scope, Identity256::from_bytes([8; 32]), 3, 5, 2,));
        assert!(!witness.matches(&issuer, &scope, identity, 4, 5, 2));
        assert!(!witness.matches(&issuer, &scope, identity, 3, 6, 2));
        assert!(!witness.matches(&issuer, &scope, identity, 3, 5, 1));
        let model = SemanticInitialPrefillContentWitness {
            slot: InitialPrefillContentSlot::Model,
            ..witness
        };
        assert!(model.matches(&issuer, &scope, identity, 3, 5, 0));
    }

    #[test]
    fn initial_prefill_parent_can_add_only_native_source_ledger_indices() {
        let expected = SemanticTextSlot {
            token: 17,
            logical_position: 3,
            kind: 1,
            provenance: 1,
            valid: 1,
            committed: 1,
            ..SemanticTextSlot::default()
        };
        let actual = SemanticTextSlot {
            provenance_record: 9,
            ..expected
        };
        assert!(same_initial_source_rows(&[expected], &[actual]));
        assert!(!same_initial_source_rows(
            &[expected],
            &[SemanticTextSlot {
                token: 18,
                ..actual
            }],
        ));
        assert!(!same_initial_source_rows(&[expected], &[]));
    }

    #[test]
    fn cold_text_parent_derives_only_contiguous_acquired_filled_coverage() {
        let rows = source_rows();
        assert_eq!(
            validate_text_parent(&rows, 0, 64, 2, 262144, 0, 3).unwrap(),
            1
        );
        assert_eq!(rows[1].kind, 2);
        assert_eq!(rows[12].logical_position, 2);
        assert_eq!(size_of::<SourceSlot>(), 64);
    }

    #[test]
    fn cold_mask_source_keeps_the_sentinel_without_fabricated_token_provenance() {
        let mut rows = [SourceSlot::default(); 32];
        rows[7] = SourceSlot {
            token: 248078,
            kind: 2,
            valid: 1,
            ..SourceSlot::default()
        };
        assert_eq!(
            validate_text_parent(&rows, 0, 64, 2, 262144, 0, 0).unwrap(),
            0
        );
        rows[7].token = 0;
        assert!(validate_text_parent(&rows, 0, 64, 2, 262144, 0, 0).is_err());
        rows[7].token = 248078;
        rows[7].provenance_record = 1;
        assert!(validate_text_parent(&rows, 0, 64, 2, 262144, 0, 2).is_err());
    }

    #[test]
    fn cold_text_parent_rejects_inconsistent_kind_and_source_metadata() {
        for field in 0..7 {
            let mut rows = source_rows();
            match field {
                0 => rows[1].provenance = 1,
                1 => rows[1].recomputed = 1,
                2 => rows[5].valid = 0,
                3 => rows[5].committed = 1,
                4 => rows[12].logical_position = 0,
                5 => rows[0].logical_position = 8,
                _ => rows[1].provenance_record = 3,
            }
            assert!(validate_text_parent(&rows, 0, 64, 2, 262144, 0, 3).is_err());
        }
    }

    #[test]
    fn cold_text_parent_checks_prefix_and_reserved_position_capacity() {
        let rows = source_rows();
        assert!(validate_text_parent(&rows, 0, 0, 2, 262144, 0, 3).is_err());
        assert!(validate_text_parent(&rows, 1, 64, 2, 262144, 0, 3).is_err());
        assert!(validate_text_parent(&rows, 0, 64, 2, 97, 0, 3).is_err());
        assert!(validate_text_parent(&rows, 0, 64, 2, 262144, 32, 3).is_err());
        assert!(validate_text_parent(&rows, 0, u64::MAX, 2, 262144, 0, 3).is_err());
    }
}

#[cfg(test)]
pub(crate) mod task_binding_tests {
    use super::*;
    use crate::{
        SemanticArgument, SemanticPolarity, SemanticPredicateRecord, SemanticSupportRecord,
        SemanticTypedRecord,
    };
    use xlog_core::{RelId, ScalarType, Schema};

    #[derive(Debug)]
    struct ArithmeticProgram;

    impl SemanticTaskProgram for ArithmeticProgram {
        fn observe(
            &self,
            _provider: Arc<CudaKernelProvider>,
        ) -> Result<SemanticTaskObservation, SemanticTransitionError> {
            Ok(arithmetic_observation())
        }
    }

    pub(crate) fn arithmetic_observation() -> SemanticTaskObservation {
        let inputs = [[1u32, 1u32], [0u32, 1u32], [1u32, 0u32]];
        let results = inputs.map(|[left, right]| (left + right) / 2);
        SemanticTaskObservation {
            program_source: b"fn observe(left: u32, right: u32) -> u32 { (left + right) / 2 }"
                .to_vec(),
            input_bytes: inputs
                .into_iter()
                .flatten()
                .flat_map(u32::to_le_bytes)
                .collect(),
            result_bytes: results.into_iter().flat_map(u32::to_le_bytes).collect(),
            expected_truth: results.map(|result| {
                if result == 1 {
                    crate::SemanticTruth::True
                } else {
                    crate::SemanticTruth::False
                }
            }),
        }
    }

    pub(crate) fn task_spec(
        statement_records: [u32; 3],
        allowed_support_records: Vec<u32>,
    ) -> SemanticTaskEvaluationSpec {
        SemanticTaskEvaluationSpec {
            statement_records,
            allowed_support_records,
            program: Arc::new(ArithmeticProgram),
            scoring: SemanticTaskScoring {
                correct_weight: 14,
                all_correct_weight: 7,
                work_weight: 1,
                improvement_weight: 45,
                refusal_weight: 15,
                spent_weight: 1,
            },
            priority_levels: Vec::new(),
            admissible_truth_masks: [7, 7, 7],
            actor_eligible: true,
            training_domain: None,
        }
    }

    fn carry_records() -> SemanticAdmissionRecords {
        let mut records = SemanticAdmissionRecords {
            predicates: vec![SemanticPredicateRecord {
                predicate: RelId(17),
                role: SemanticRecordRole::Statement,
                schema: Schema::new(vec![
                    ("left".into(), ScalarType::U32),
                    ("right".into(), ScalarType::U32),
                ])
                .with_sort_labels(vec!["bit".into(), "bit".into()])
                .unwrap(),
            }],
            records: vec![
                SemanticTypedRecord {
                    predicate: RelId(17),
                    arguments: vec![SemanticArgument::U32(1), SemanticArgument::U32(1)],
                    qualifiers: vec![],
                },
                SemanticTypedRecord {
                    predicate: RelId(17),
                    arguments: vec![SemanticArgument::U32(0), SemanticArgument::U32(1)],
                    qualifiers: vec![],
                },
            ],
            supports: vec![SemanticSupportRecord {
                statement: 0,
                polarity: SemanticPolarity::Pro,
                provenance: 2,
                source: 3,
                context: 4,
                scope: 5,
            }],
        };
        for (index, role) in [
            SemanticRecordRole::Provenance,
            SemanticRecordRole::Source,
            SemanticRecordRole::Context,
            SemanticRecordRole::Scope,
        ]
        .into_iter()
        .enumerate()
        {
            let predicate = RelId(18 + index as u32);
            records.predicates.push(SemanticPredicateRecord {
                predicate,
                role,
                schema: Schema::new(vec![]),
            });
            records.records.push(SemanticTypedRecord {
                predicate,
                arguments: vec![],
                qualifiers: vec![],
            });
        }
        records
    }

    #[test]
    fn task_query_validation_does_not_interpret_argument_values() {
        let mut records = carry_records();
        records.records[0].arguments = vec![SemanticArgument::U32(17), SemanticArgument::U32(23)];
        task_spec([0, 1, 1], vec![0])
            .validate_records(&records)
            .unwrap();
    }

    #[test]
    fn application_observer_retains_input_and_output_bytes() {
        let observation = arithmetic_observation();
        assert_eq!(
            observation.input_bytes,
            [1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,]
        );
        assert_eq!(
            observation.result_bytes,
            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        );
        assert_eq!(
            observation.expected_truth,
            [
                crate::SemanticTruth::True,
                crate::SemanticTruth::False,
                crate::SemanticTruth::False,
            ]
        );
    }

    #[test]
    fn cold_content_matches_final_task_without_scoring_or_authority_inputs() {
        let admission = crate::semantic_hypergraph::tests::admit_material_records(carry_records());
        let cold = TaskEvaluationBinding::cold_content(
            &admission,
            [0, 1, 1],
            &[0],
            None,
            arithmetic_observation(),
        )
        .unwrap();
        let mut spec = task_spec([0, 1, 1], vec![0]);
        let bound = TaskEvaluationBinding::bind(&admission, spec.clone(), arithmetic_observation())
            .unwrap();
        assert_eq!(cold, bound.content());

        spec.scoring.correct_weight += 1;
        spec.actor_eligible = false;
        assert_eq!(
            cold,
            TaskEvaluationBinding::bind(&admission, spec, arithmetic_observation())
                .unwrap()
                .content(),
        );

        let mut changed = arithmetic_observation();
        changed.result_bytes.push(0);
        assert_ne!(
            cold,
            TaskEvaluationBinding::cold_content(&admission, [0, 1, 1], &[0], None, changed)
                .unwrap(),
        );

        let mut changed_query = arithmetic_observation();
        changed_query.input_bytes.push(0);
        assert_ne!(
            cold,
            TaskEvaluationBinding::cold_content(&admission, [0, 1, 1], &[0], None, changed_query,)
                .unwrap(),
        );
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn task_result_material_binds_native_observer_program_and_results() {
        let admission = crate::semantic_hypergraph::tests::admit_material_records(carry_records());
        let original_observation = arithmetic_observation();
        let binding = TaskEvaluationBinding::bind(
            &admission,
            task_spec([0, 1, 1], vec![0]),
            arithmetic_observation(),
        )
        .unwrap();
        let material = binding.completed_result_material();
        assert_eq!(
            Sha256::digest(&material.bytes).as_slice(),
            material.identity.as_bytes()
        );
        assert!(material
            .bytes
            .windows(original_observation.result_bytes.len())
            .any(|part| part == original_observation.result_bytes));

        let mut changed = original_observation;
        changed.program_source.push(b' ');
        let changed =
            TaskEvaluationBinding::bind(&admission, task_spec([0, 1, 1], vec![0]), changed)
                .unwrap();
        assert_ne!(
            changed.completed_result_material().identity,
            material.identity
        );
    }

    #[test]
    fn task_binding_identity_seals_observer_execution_and_configuration() {
        let admission = crate::semantic_hypergraph::tests::admit_material_records(carry_records());
        let identity = |spec, observation| {
            TaskEvaluationBinding::bind(&admission, spec, observation)
                .unwrap()
                .identity()
        };
        let original = identity(task_spec([0, 1, 1], vec![0]), arithmetic_observation());
        assert_eq!(
            original,
            identity(task_spec([0, 1, 1], vec![0]), arithmetic_observation()),
            "independent bindings with identical bytes must have the same identity"
        );
        for changed in 0..15 {
            let mut spec = task_spec([0, 1, 1], vec![0]);
            let mut observation = arithmetic_observation();
            let field = match changed {
                0 => {
                    observation.program_source.push(b' ');
                    "program source"
                }
                1 => {
                    observation.input_bytes.push(0);
                    "observer inputs"
                }
                2 => {
                    observation.result_bytes.push(0);
                    "observer results"
                }
                3 => {
                    observation.expected_truth[0] = crate::SemanticTruth::Both;
                    "first expected truth"
                }
                4 => {
                    observation.expected_truth[1] = crate::SemanticTruth::Neither;
                    "second expected truth"
                }
                5 => {
                    observation.expected_truth[2] = crate::SemanticTruth::Neither;
                    "third expected truth"
                }
                6 => {
                    spec.scoring.correct_weight += 1;
                    "correct weight"
                }
                7 => {
                    spec.scoring.all_correct_weight += 1;
                    "all-correct weight"
                }
                8 => {
                    spec.scoring.work_weight += 1;
                    "work weight"
                }
                9 => {
                    spec.scoring.improvement_weight += 1;
                    "improvement weight"
                }
                10 => {
                    spec.scoring.refusal_weight += 1;
                    "refusal weight"
                }
                11 => {
                    spec.scoring.spent_weight += 1;
                    "spent weight"
                }
                12 => {
                    spec.admissible_truth_masks[0] = 15;
                    "first truth mask"
                }
                13 => {
                    spec.admissible_truth_masks[1] = 15;
                    "second truth mask"
                }
                _ => {
                    spec.admissible_truth_masks[2] = 15;
                    "third truth mask"
                }
            };
            assert_ne!(
                original,
                identity(spec, observation),
                "identity omitted {field}"
            );
        }
    }

    #[test]
    fn task_truth_eligibility_requires_nonempty_four_valued_masks() {
        let admission = crate::semantic_hypergraph::tests::admit_material_records(carry_records());
        for slot in 0..3 {
            for mask in [0, 16, 128, 255] {
                let mut spec = task_spec([0, 1, 1], vec![0]);
                spec.admissible_truth_masks[slot] = mask;
                let result =
                    TaskEvaluationBinding::bind(&admission, spec, arithmetic_observation());
                assert!(
                    matches!(result, Err(SemanticTransitionError::InvalidInput { detail })
                    if detail.contains("nonempty four-valued mask")),
                    "slot {slot}, mask {mask}"
                );
            }
            for mask in 1..=15 {
                let mut spec = task_spec([0, 1, 1], vec![0]);
                spec.admissible_truth_masks[slot] = mask;
                TaskEvaluationBinding::bind(&admission, spec, arithmetic_observation()).unwrap();
            }
        }
    }

    #[test]
    fn rule_codebook_covers_the_complete_admitted_binary_schema() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};

        let admission = admit_material_records(root_material_records());
        let program = crate::SemanticProgramAdmission {
            predicate_count: 5,
            initial_facts: vec![],
            initial_rules: vec![],
            queries: [
                crate::SemanticProgramFact {
                    predicate: 4,
                    first: 1,
                    second: 3,
                },
                crate::SemanticProgramFact {
                    predicate: 4,
                    first: 1,
                    second: 4,
                },
                crate::SemanticProgramFact {
                    predicate: 4,
                    first: 4,
                    second: 3,
                },
            ],
        };
        let generic = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let books = ActionCodebooks::derive(&admission, 1, Some(&program)).unwrap();
        assert_eq!(books.targets[..generic.targets.len()], generic.targets);
        assert_eq!(
            books.targets[generic.targets.len()..]
                .iter()
                .filter_map(|descriptor| match descriptor {
                    SemanticActionDescriptor::RulePredicate { predicate } => Some(*predicate),
                    _ => None,
                })
                .collect::<Vec<_>>(),
            (0..5).collect::<Vec<_>>()
        );
        assert_eq!(books.qualifiers.len(), generic.qualifiers.len());
        assert_eq!(books.leaves.len(), generic.leaves.len());
        assert_eq!(books.operands[..generic.operands.len()], generic.operands);
        assert_eq!(
            books.operands[generic.operands.len()..]
                .iter()
                .filter_map(|descriptor| match descriptor {
                    SemanticActionDescriptor::RulePredicate { predicate } => Some(*predicate),
                    _ => None,
                })
                .collect::<Vec<_>>(),
            (0..5).collect::<Vec<_>>()
        );
        assert_eq!(
            books.operands[generic.operands.len()..]
                .iter()
                .filter_map(|descriptor| match descriptor {
                    SemanticActionDescriptor::RuleVariable { index } => Some(*index),
                    _ => None,
                })
                .collect::<Vec<_>>(),
            (0..4).collect::<Vec<_>>()
        );
        for field in 3..=10 {
            assert_eq!(
                books.components[32 + field].cardinality as usize,
                books.operands.len() + 1
            );
        }
        for field in 7..=10 {
            assert_eq!(generic.components[32 + field].cardinality, 1);
        }
        assert_ne!(books.binding.digest, generic.binding.digest);

        let mut changed_program = program.clone();
        changed_program
            .initial_facts
            .push(crate::SemanticProgramFact {
                predicate: 0,
                first: 10,
                second: 11,
            });
        let changed = ActionCodebooks::derive(&admission, 1, Some(&changed_program)).unwrap();
        assert_ne!(books.binding.digest, changed.binding.digest);

        let predicate = |index| generic.operands.len() as u32 + 1 + index;
        let variable = |index| generic.operands.len() as u32 + 6 + index;
        let mut choices = [0u32; 18];
        choices[0] = 1;
        choices[1] = 2;
        choices[2] = generic.targets.len() as u32 + 5;
        choices[3] = predicate(0);
        choices[4] = predicate(1);
        choices[5] = variable(0);
        choices[6] = variable(2);
        choices[7] = variable(0);
        choices[8] = variable(1);
        choices[9] = variable(1);
        choices[10] = variable(2);
        let decoded = books.decoded_rule_insertion(&program, &choices).unwrap();
        assert_eq!(decoded.rule.head_predicate, 4);
        assert_eq!(decoded.rule.head_variables, [0, 2]);
        assert!(decoded.bytes.starts_with(b"XLOG-DECODED-RULE-INSERTION\0"));
        choices[6] = variable(3);
        assert!(books.decoded_rule_insertion(&program, &choices).is_err());
        choices[6] = variable(2);
        choices[3] = 1;
        assert!(books.decoded_rule_insertion(&program, &choices).is_err());

        let mut too_many_predicates = program;
        too_many_predicates.predicate_count = 65_536;
        assert!(ActionCodebooks::derive(&admission, 1, Some(&too_many_predicates)).is_err());
    }

    #[test]
    fn action_leaf_categories_preserve_equal_original_supports() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};
        let mut records = root_material_records();
        records.supports.push(records.supports[0].clone());
        records.supports.push(records.supports[0].clone());
        records.supports.last_mut().unwrap().statement = 1;
        let original_count = records.supports.len();
        let admission = admit_material_records(records);
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        assert_eq!(books.leaves.len(), original_count);
        assert_eq!(books.words[7], original_count as u64 + 1);
        let mut seen = BTreeSet::new();
        for (category, meaning) in books.leaves.iter().enumerate() {
            let SemanticActionDescriptor::SupportEvent { source_record } = meaning else {
                panic!("wrong leaf meaning")
            };
            assert!(seen.insert(*source_record));
            assert_eq!(
                books.words[books.words[6] as usize + 18 * (category + 1) + 17],
                u64::from(*source_record)
            );
        }
        assert_eq!(seen, (0..original_count as u32).collect());
        let layout = SemanticPolicyLayout::from_components(&books.components).unwrap();
        assert_eq!(layout.fields[17].cardinality, original_count + 1);
        assert_eq!(layout.fields[17].embeddings.len(), original_count * 128);
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn policy_producer_geometry_keeps_full_mask_rows_and_boolean_support() {
        let layouts = policy_producer_layouts(97, 129).unwrap();
        let metadata = TensorMetadata {
            device_type: 2,
            device_id: 0,
            dtype: crate::dlpack::DLDataType {
                code: 2,
                bits: 32,
                lanes: 1,
            },
            shape: &[32, TEXT_CARDINALITY as i64],
            strides: None,
            data: 4096,
            byte_offset: 4,
        };
        assert_eq!(
            validate_tensor_metadata(&layouts[0], &metadata, 0).unwrap(),
            (4100, 32 * TEXT_CARDINALITY * 4)
        );
        let mut malformed = metadata;
        malformed.shape = &[1, TEXT_CARDINALITY as i64];
        assert!(validate_tensor_metadata(&layouts[0], &malformed, 0).is_err());
        malformed.shape = &[32 * TEXT_CARDINALITY as i64];
        assert!(validate_tensor_metadata(&layouts[0], &malformed, 0).is_err());
        malformed.shape = &[32, TEXT_CARDINALITY as i64];
        malformed.strides = Some(&[TEXT_CARDINALITY as i64 + 1, 1]);
        assert!(validate_tensor_metadata(&layouts[0], &malformed, 0).is_err());
        let support = TensorMetadata {
            device_type: 2,
            device_id: 0,
            dtype: crate::dlpack::DLDataType {
                code: 6,
                bits: 8,
                lanes: 1,
            },
            shape: &[97],
            strides: Some(&[1]),
            data: 4096,
            byte_offset: 0,
        };
        assert_eq!(
            validate_tensor_metadata(&layouts[1], &support, 0).unwrap(),
            (4096, 97)
        );
        let mut wrong_dtype = support;
        wrong_dtype.dtype.code = 1;
        assert!(validate_tensor_metadata(&layouts[1], &wrong_dtype, 0).is_err());
        assert_eq!(layouts[2].dimensions, [129, 0, 0, 0]);
    }

    #[test]
    fn policy_support_reserves_every_original_category_span() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};
        let admission = admit_material_records(root_material_records());
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let (spans, cells) = books.support_layout();
        assert_eq!(spans.len(), COMPONENT_COUNT);
        let mut cursor = 0;
        for (span, component) in spans.iter().zip(&books.components) {
            assert_eq!(span.start, cursor);
            assert_eq!(span.start, component.offset as usize);
            assert_eq!(span.len(), component.cardinality as usize);
            cursor = span.end;
        }
        assert_eq!(cells, cursor);
        assert_eq!(cells, books.input_cells);
        for lane in 0..2 {
            for slot in 0..32 {
                assert_eq!(spans[lane * 68 + slot].len(), TEXT_CARDINALITY);
            }
        }
    }

    #[test]
    fn action_codebooks_retain_typed_reconstruction_sources() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};
        let admission = admit_material_records(root_material_records());
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        assert_eq!(
            books.words[4] - books.words[2],
            6 * books.words[3],
            "operand bank lost original argument reconstruction references"
        );
        assert_eq!(
            books.words[6] - books.words[4],
            3 * books.words[5],
            "qualifier bank lost original bundle reconstruction references"
        );
        for (category, meaning) in books.operands.iter().enumerate() {
            let SemanticActionDescriptor::Operand { encoded_value, .. } = meaning else {
                panic!("wrong operand meaning")
            };
            let row = books.words[2] as usize + 6 * (category + 1);
            let source = &admission.encoded_records[books.words[row + 4] as usize];
            assert_eq!(
                &source.bytes[source.arguments[books.words[row + 5] as usize].clone()],
                encoded_value
            );
        }
        for (category, meaning) in books.qualifiers.iter().enumerate() {
            let SemanticActionDescriptor::QualifierBundle { records } = meaning else {
                panic!("wrong qualifier meaning")
            };
            let source = books.words[books.words[4] as usize + 3 * (category + 1) + 2];
            if records.is_empty() {
                assert_eq!(source, u64::from(u32::MAX));
            } else {
                assert_eq!(
                    &admission.records().records[source as usize].qualifiers,
                    records
                );
            }
        }
    }

    #[cfg(feature = "semantic-policy")]
    #[test]
    fn completed_action_law_and_codebook_materials_match_native_bindings() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};

        let catalogue = SemanticActionCatalogue::current();
        let law = catalogue.completed_material();
        assert_eq!(law.identity, catalogue.binding().digest);
        assert_eq!(law.bytes, catalogue.canonical_bytes());
        assert_eq!(
            Sha256::digest(&law.bytes).as_slice(),
            law.identity.as_bytes()
        );

        let admission = admit_material_records(root_material_records());
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let codebook = books.completed_material();
        assert_eq!(codebook.identity, books.binding.digest);
        assert_eq!(codebook.bytes, publication_abi_bytes(&books.words));
        assert_ne!(codebook.identity, law.identity);
        assert_ne!(codebook.bytes, law.bytes);

        let roster = books.completed_roster_material();
        assert_eq!(
            Sha256::digest(&roster.bytes).as_slice(),
            roster.identity.as_bytes()
        );
        assert_eq!(
            &roster.bytes[b"xlog.semantic-action-roster.v1\0".len()
                ..b"xlog.semantic-action-roster.v1\0".len() + 32],
            books.binding.digest.as_bytes()
        );
        assert_eq!(books.components.len(), COMPONENT_COUNT);
        let roster_rows = &roster.bytes[b"xlog.semantic-action-roster.v1\0".len() + 32 + 8..];
        assert_eq!(roster_rows.len(), COMPONENT_COUNT * 7 * 8);
        for (row, component) in roster_rows.chunks_exact(7 * 8).zip(&books.components) {
            let values: Vec<u64> = row
                .chunks_exact(8)
                .map(|word| u64::from_le_bytes(word.try_into().unwrap()))
                .collect();
            assert_eq!(
                values,
                [
                    component.offset,
                    component.ordinal as u64,
                    component.lane as u64,
                    component.slot as u64,
                    component.field as u64,
                    component.kind as u64,
                    component.cardinality as u64,
                ]
            );
        }
        assert_ne!(roster.identity, codebook.identity);
        let other_owner_books = ActionCodebooks::derive(&admission, 2, None).unwrap();
        assert_ne!(
            other_owner_books.completed_material().identity,
            codebook.identity
        );
        assert_ne!(
            other_owner_books.completed_roster_material().identity,
            roster.identity
        );
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn decoded_support_insertion_matches_admitted_native_identity() {
        use crate::semantic_hypergraph::tests::{
            admit_material_records, reconstructed_material_statement, root_material_records,
        };

        let admission = admit_material_records(root_material_records());
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let mut choices = [0u32; 18];
        choices[0] = 1;
        choices[1] = 1;
        choices[2] = 1;
        choices[3] = 1;
        choices[11] = 1;
        choices[17] = 1;
        let decoded = books
            .decoded_support_insertion(&admission, &choices)
            .unwrap()
            .unwrap();
        let statement =
            reconstructed_material_statement(&admission, None, &decoded.reconstruction).unwrap();
        assert_eq!(decoded.statement, statement.identity());
        assert_eq!(
            decoded.support,
            admission
                .support_event(decoded.source_event)
                .unwrap()
                .identity(decoded.statement)
        );
        assert!(decoded
            .bytes
            .starts_with(b"XLOG-DECODED-SUPPORT-INSERTION\0"));
        choices[0] = 0;
        assert!(books
            .decoded_support_insertion(&admission, &choices)
            .unwrap()
            .is_none());
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn completed_theory_delta_requires_an_attempted_native_insertion() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};

        let admission = admit_material_records(root_material_records());
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let mut choices = [0u32; 18];
        choices[0] = 1;
        choices[1] = 1;
        choices[2] = 1;
        choices[3] = 1;
        choices[11] = 1;
        choices[17] = 1;
        let decoded = books
            .decoded_support_insertion(&admission, &choices)
            .unwrap()
            .unwrap();
        let owner = Identity256::from_bytes([3; 32]);
        let predecessor = Identity256::from_bytes([4; 32]);
        let mut hard_decode = [0u64; 42];
        hard_decode[1] = 1;
        hard_decode[20..24].copy_from_slice(&identity_words(*decoded.statement.as_bytes()));
        hard_decode[24..28].copy_from_slice(&identity_words(*decoded.support.as_bytes()));
        let admission_receipt = [0u64; 42];
        let components = [SemanticTransitionReceipt::default(); 18];
        let delta = completed_theory_delta_for_slot(
            &books,
            &admission,
            None,
            Identity256::from_bytes([0; 32]),
            owner,
            predecessor,
            0,
            0,
            &choices,
            None,
            &hard_decode,
            &admission_receipt,
            &components,
            0,
        )
        .unwrap()
        .unwrap();
        assert_eq!(delta.kind, "fact");
        assert_eq!(delta.theory_generation, predecessor);
        assert_eq!(delta.verdict, "accepted");
        assert!(delta
            .delta
            .bytes
            .windows(decoded.bytes.len())
            .any(|part| part == decoded.bytes));
        hard_decode[20] ^= 1;
        assert!(completed_theory_delta_for_slot(
            &books,
            &admission,
            None,
            Identity256::from_bytes([0; 32]),
            owner,
            predecessor,
            0,
            0,
            &choices,
            None,
            &hard_decode,
            &admission_receipt,
            &components,
            0,
        )
        .is_err());
        hard_decode[1] = 0;
        assert!(completed_theory_delta_for_slot(
            &books,
            &admission,
            None,
            Identity256::from_bytes([0; 32]),
            owner,
            predecessor,
            0,
            0,
            &choices,
            None,
            &hard_decode,
            &admission_receipt,
            &components,
            1,
        )
        .unwrap()
        .is_none());
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn decoded_rule_delta_seals_every_structural_field_and_prior_edit() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};

        let admission = admit_material_records(root_material_records());
        let program = crate::SemanticProgramAdmission {
            predicate_count: 3,
            initial_facts: vec![],
            initial_rules: vec![],
            queries: [
                crate::SemanticProgramFact {
                    predicate: 2,
                    first: 1,
                    second: 3,
                },
                crate::SemanticProgramFact {
                    predicate: 2,
                    first: 1,
                    second: 4,
                },
                crate::SemanticProgramFact {
                    predicate: 2,
                    first: 4,
                    second: 3,
                },
            ],
        };
        let generic = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let books = ActionCodebooks::derive(&admission, 1, Some(&program)).unwrap();
        let predicate = |index| generic.operands.len() as u32 + 1 + index;
        let variable = |index| generic.operands.len() as u32 + 4 + index;
        let mut choices = [0u32; 18];
        choices[0] = 1;
        choices[1] = 2;
        choices[2] = generic.targets.len() as u32 + 3;
        choices[3] = predicate(0);
        choices[4] = predicate(1);
        choices[5] = variable(0);
        choices[6] = variable(2);
        choices[7] = variable(0);
        choices[8] = variable(1);
        choices[9] = variable(1);
        choices[10] = variable(2);
        let decoded = books.decoded_rule_insertion(&program, &choices).unwrap();
        assert_eq!(decoded.rule.head_predicate, 2);
        assert_eq!(decoded.rule.head_variables, [0, 2]);
        let owner = Identity256::from_bytes([3; 32]);
        let predecessor = Identity256::from_bytes([4; 32]);
        let task = Identity256::from_bytes([9; 32]);
        let mut hard_decode = [0u64; 42];
        hard_decode[1] = 3;
        hard_decode[2] = 1;
        hard_decode[4..8].copy_from_slice(&identity_words(*task.as_bytes()));
        hard_decode[8..12].copy_from_slice(&identity_words(*books.binding.digest.as_bytes()));
        hard_decode[12..22].copy_from_slice(&semantic_program_rule_words(decoded.rule));
        let admission_receipt = [0u64; 42];
        let components = [SemanticTransitionReceipt::default(); 18];
        let project = |receipt: &[u64; 42], slot, previous| {
            completed_theory_delta_for_slot(
                &books,
                &admission,
                Some(&program),
                task,
                owner,
                predecessor,
                0,
                slot,
                &choices,
                previous,
                receipt,
                &admission_receipt,
                &components,
                0,
            )
        };
        let delta = project(&hard_decode, 0, None).unwrap().unwrap();
        assert_eq!(delta.kind, "rule");
        assert_eq!(
            delta.theory_generation,
            ActionCodebooks::program_binding(&program)
        );
        for field in 12..22 {
            let mut changed = hard_decode;
            changed[field] ^= 1;
            assert!(
                project(&changed, 0, None).is_err(),
                "unsealed rule field {field}"
            );
        }
        let mut second = hard_decode;
        second[3] = 1;
        second[24] = 1;
        second[25..35].copy_from_slice(&semantic_program_rule_words(decoded.rule));
        let second_delta = project(&second, 1, Some(&choices)).unwrap().unwrap();
        assert_ne!(second_delta.theory_generation, delta.theory_generation);
        second[25] ^= 1;
        assert!(project(&second, 1, Some(&choices)).is_err());
        let mut invalid = choices;
        invalid[6] = variable(3);
        assert!(books.decoded_rule_insertion(&program, &invalid).is_err());
        invalid = choices;
        invalid[3] = 1;
        assert!(books.decoded_rule_insertion(&program, &invalid).is_err());

        let mut fact_choices = [0u32; 18];
        fact_choices[0] = 1;
        fact_choices[1] = 1;
        fact_choices[2] = 1;
        fact_choices[3] = 1;
        fact_choices[11] = 1;
        fact_choices[17] = 1;
        let fact = books
            .decoded_support_insertion(&admission, &fact_choices)
            .unwrap()
            .unwrap();
        let mut fact_receipt = [0u64; 42];
        fact_receipt[1] = 1;
        fact_receipt[20..24].copy_from_slice(&identity_words(*fact.statement.as_bytes()));
        fact_receipt[24..28].copy_from_slice(&identity_words(*fact.support.as_bytes()));
        assert!(completed_theory_delta_for_slot(
            &books,
            &admission,
            Some(&program),
            task,
            owner,
            predecessor,
            0,
            0,
            &fact_choices,
            None,
            &fact_receipt,
            &admission_receipt,
            &components,
            0,
        )
        .is_err());
    }

    #[test]
    fn program_query_receipts_bind_each_executed_query_to_the_program() {
        use crate::semantic_hypergraph::tests::{admit_material_records, root_material_records};

        let admission = admit_material_records(root_material_records());
        let fact = crate::SemanticProgramFact {
            predicate: 0,
            first: 1,
            second: 2,
        };
        let program = crate::SemanticProgramAdmission {
            predicate_count: 1,
            initial_facts: vec![fact],
            initial_rules: vec![],
            queries: [fact; 3],
        };
        let books = ActionCodebooks::derive(&admission, 1, Some(&program)).unwrap();
        let task = Identity256::from_bytes([7; 32]);
        let edits = [[[0u32; 18]; 2]; 2];
        let mut state = DeviceState {
            binding_digest: books.binding.digest,
            ..DeviceState::default()
        };
        state.task_evaluation.query_count = 9;
        for slot in 0..3 {
            state.task_evaluation.facts[slot].truth = [1; 3];
            for query in 0..3 {
                let receipt = &mut state.task_evaluation.query_receipts[slot][query];
                receipt[1] = 0x5850524f47515545;
                receipt[2] = 1;
                receipt[3] = slot as u64;
                receipt[4] = query as u64;
                receipt[5..9].copy_from_slice(&identity_words(*task.as_bytes()));
                receipt[9..13].copy_from_slice(&identity_words(*books.binding.digest.as_bytes()));
                receipt[34..37].copy_from_slice(&[0, 1, 2]);
                receipt[38] = 1;
                receipt[41] = 1;
            }
        }
        assert!(validate_program_query_receipts(&program, task, &books, &state, &edits).is_ok());
        state.task_evaluation.query_receipts[2][1][34] = 1;
        assert!(validate_program_query_receipts(&program, task, &books, &state, &edits).is_err());
        state.task_evaluation.query_receipts[2][1][34] = 0;
        let mut fact_edit = edits;
        fact_edit[0][0][0] = 1;
        fact_edit[0][0][1] = 1;
        assert!(
            validate_program_query_receipts(&program, task, &books, &state, &fact_edit).is_err()
        );

        let generic = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let predicate = generic.operands.len() as u32 + 1;
        let first = predicate + 1;
        let second = first + 1;
        let mut rule_choice = [0u32; 18];
        rule_choice[0..11].copy_from_slice(&[
            1,
            2,
            generic.targets.len() as u32 + 1,
            predicate,
            predicate,
            first,
            second,
            first,
            second,
            first,
            second,
        ]);
        let rule = books
            .decoded_rule_insertion(&program, &rule_choice)
            .unwrap()
            .rule;
        let mut rule_edits = edits;
        rule_edits[0] = [rule_choice; 2];
        for query in 0..3 {
            let receipt = &mut state.task_evaluation.query_receipts[1][query];
            receipt[13] = 2;
            receipt[14..24].copy_from_slice(&semantic_program_rule_words(rule));
            receipt[24..34].copy_from_slice(&semantic_program_rule_words(rule));
            receipt[37] = 2;
        }
        state.work[0].edit_commands = 2;
        assert!(
            validate_program_query_receipts(&program, task, &books, &state, &rule_edits).is_ok()
        );
        state.task_evaluation.query_receipts[1][2][25] ^= 1;
        assert!(
            validate_program_query_receipts(&program, task, &books, &state, &rule_edits).is_err()
        );

        let mut hard_decode = [0u64; 42];
        hard_decode[1] = 3;
        hard_decode[2] = 1;
        hard_decode[4..8].copy_from_slice(&identity_words(*task.as_bytes()));
        hard_decode[8..12].copy_from_slice(&identity_words(*books.binding.digest.as_bytes()));
        hard_decode[12..22].copy_from_slice(&semantic_program_rule_words(rule));
        hard_decode[22] = 1;
        assert_eq!(
            validated_rule_receipt(
                &books,
                &program,
                task,
                0,
                0,
                &rule_choice,
                None,
                &hard_decode,
            )
            .unwrap()
            .0
            .rule,
            rule
        );
        hard_decode[12] ^= 1;
        assert!(validated_rule_receipt(
            &books,
            &program,
            task,
            0,
            0,
            &rule_choice,
            None,
            &hard_decode,
        )
        .is_err());
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn completed_task_scoring_matches_native_work_and_selection() {
        let scoring = task_spec([0, 1, 0], vec![]).scoring;
        let facts = [
            SemanticTaskFacts {
                g: 1,
                v: 14,
                eligible: 1,
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts {
                g: 2,
                c: 3,
                v: 25,
                eligible: 1,
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts::default(),
        ];
        let work = [
            SemanticTransitionWork {
                edit_commands: 1,
                added_supports: 1,
                defined_truth_changes: 1,
            },
            SemanticTransitionWork::default(),
        ];
        assert!(validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &facts,
            &work,
            [0, 1],
            6,
            1,
            474,
        ));
        let mut changed = facts;
        changed[1].c = 2;
        assert!(!validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &changed,
            &work,
            [0, 1],
            6,
            1,
            474,
        ));
        changed = facts;
        changed[1].v = 26;
        assert!(!validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &changed,
            &work,
            [0, 1],
            6,
            1,
            474,
        ));
        assert!(!validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &facts,
            &work,
            [0, 1],
            6,
            0,
            474,
        ));
        assert!(!validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &facts,
            &work,
            [0, 1],
            6,
            1,
            475,
        ));

        let mut refused_after_first_edit = facts;
        refused_after_first_edit[2].c = 3;
        refused_after_first_edit[2].v = -3;
        let partial_work = [work[0], work[0]];
        assert!(validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &refused_after_first_edit,
            &partial_work,
            [0, 1],
            6,
            1,
            472,
        ));

        let mut tied = facts;
        tied[1].g = 1;
        tied[1].c = 0;
        tied[1].v = 14;
        assert!(validate_completed_task_scoring(
            scoring,
            false,
            &[],
            &tied,
            &[SemanticTransitionWork::default(); 2],
            [0, 1],
            6,
            0,
            -21,
        ));
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn task_priority_can_select_lower_value_and_negative_return() {
        let scoring = task_spec([0, 1, 0], vec![]).scoring;
        let priority_levels = [SemanticTaskPriorityLevel {
            goals: vec![SemanticTaskPriorityGoal {
                query: 0,
                target_truth: 1,
                weight: 1,
            }],
        }];
        let facts = [
            SemanticTaskFacts {
                g: 2,
                v: 28,
                eligible: 1,
                truth: [0, 1, 1],
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts {
                g: 1,
                c: 1,
                v: 13,
                eligible: 1,
                truth: [1, 0, 0],
                ..SemanticTaskFacts::default()
            },
            SemanticTaskFacts::default(),
        ];
        let work = [
            SemanticTransitionWork {
                edit_commands: 1,
                ..SemanticTransitionWork::default()
            },
            SemanticTransitionWork::default(),
        ];
        let return_value = 45 * (13 - 28) - 3;
        assert!(return_value < -44);
        assert!(i64::from(return_value).abs() <= scoring.return_bound(false).unwrap());
        assert!(validate_completed_task_scoring(
            scoring,
            false,
            &priority_levels,
            &facts,
            &work,
            [0, 0],
            3,
            1,
            i64::from(return_value),
        ));
    }

    #[test]
    #[cfg(feature = "semantic-policy")]
    fn completed_task_scoring_law_retains_coefficients_and_finite_bound() {
        let scoring = task_spec([0, 1, 0], vec![]).scoring;
        let task = Identity256::from_bytes([11; 32]);
        let bytes = scoring.completed_law_bytes(task, false).unwrap();
        let mut expected = b"XLOG-TASK-SCORING-LAW\0".to_vec();
        expected.extend_from_slice(&2u64.to_le_bytes());
        expected.extend_from_slice(task.as_bytes());
        let cost = semantic_structural_cost_descriptor(false);
        expected.extend_from_slice(cost.unit.as_bytes());
        expected.extend_from_slice(&cost.cap.to_le_bytes());
        for weight in [14u64, 7, 1, 45, 15, 1] {
            expected.extend_from_slice(&weight.to_le_bytes());
        }
        expected.extend_from_slice(&scoring.return_bound(false).unwrap().to_le_bytes());
        assert_eq!(bytes, expected);
        assert_eq!(scoring.return_bound(false).unwrap(), 2522);
        let structural = scoring.completed_law_bytes(task, true).unwrap();
        assert_eq!(scoring.return_bound(true).unwrap(), 186799);
        assert_eq!(
            structural[structural.len() - size_of::<i64>()..],
            scoring.return_bound(true).unwrap().to_le_bytes()
        );
    }

    #[test]
    fn checkpoint_scoring_identity_tracks_the_bound_law() {
        let scoring = SemanticTaskScoring {
            correct_weight: 14,
            all_correct_weight: 7,
            work_weight: 1,
            improvement_weight: 45,
            refusal_weight: 15,
            spent_weight: 1,
        };
        let task = SemanticTaskContentIdentity {
            query: Identity256::from_bytes([11; 32]),
            theory_program: Identity256::from_bytes([12; 32]),
            result: Identity256::from_bytes([13; 32]),
        };
        let baseline = checkpoint_scoring_law_identity(
            scoring,
            task,
            scoring.objective_law(false).unwrap(),
            None,
        );
        assert_ne!(
            baseline,
            checkpoint_scoring_law_identity(
                scoring,
                task,
                scoring.objective_law(true).unwrap(),
                None
            )
        );
        let mut changed = scoring;
        changed.correct_weight += 1;
        assert_ne!(
            baseline,
            checkpoint_scoring_law_identity(
                changed,
                task,
                changed.objective_law(false).unwrap(),
                None
            )
        );
    }

    pub(crate) fn verify_native_decoded_reconstruction(
        executable: &std::path::Path,
        directory: &std::path::Path,
        run: &impl Fn(&mut std::process::Command),
    ) {
        use crate::semantic_hypergraph::tests::{
            admit_material_records, reconstructed_material_statement, root_material_records,
        };
        let mut records = root_material_records();
        records.supports.push(records.supports[0].clone());
        let admission = admit_material_records(records);
        let books = ActionCodebooks::derive(&admission, 1, None).unwrap();
        let leaf = books
            .leaves
            .iter()
            .position(|value| {
                matches!(
                    value,
                    SemanticActionDescriptor::SupportEvent { source_record: 3 }
                )
            })
            .unwrap() as u32
            + 1;
        for (ordinal, operand) in [1, books.operands.len() as u32].into_iter().enumerate() {
            let mut choices = [0u32; SEMANTIC_TRANSITION_COMPONENT_COUNT];
            choices[2] = 1;
            choices[3] = operand;
            choices[11] = 1;
            choices[17] = leaf;
            let mut input = format!("{}\n", books.words.len());
            for word in &books.words {
                input.push_str(&format!("{word} "));
            }
            for choice in choices {
                input.push_str(&format!("{choice} "));
            }
            let source = directory.join(format!("decoded-input-{ordinal}.txt"));
            let destination = directory.join(format!("decoded-output-{ordinal}.txt"));
            std::fs::write(&source, input).unwrap();
            run(std::process::Command::new(executable)
                .arg("--decode")
                .arg(&source)
                .arg(&destination));
            let words: Vec<u32> = std::fs::read_to_string(&destination)
                .unwrap()
                .split_whitespace()
                .map(|word| word.parse().unwrap())
                .collect();
            assert_eq!(words.len(), 20);
            assert_eq!(
                words[8],
                u32::MAX,
                "computed target invented an original occurrence"
            );
            assert_eq!(
                words[19], 3,
                "actual decoder selected a different equal support occurrence"
            );
            let reconstruction: [u32; 10] = words[9..19].try_into().unwrap();
            let key = reconstructed_material_statement(&admission, None, &reconstruction).unwrap();
            let digest: Vec<u8> = words[..8]
                .iter()
                .flat_map(|word| word.to_le_bytes())
                .collect();
            assert_eq!(
                digest.as_slice(),
                key.identity().as_bytes(),
                "actual decode differs from canonical restore"
            );
            if ordinal == 0 {
                assert_eq!(
                    key.identity(),
                    admission.statement_key(0).unwrap().identity()
                );
            } else {
                assert_ne!(
                    key.identity(),
                    admission.statement_key(0).unwrap().identity()
                );
                assert_ne!(
                    key.identity(),
                    admission.statement_key(1).unwrap().identity()
                );
            }
            assert!(
                reconstructed_material_statement(&admission, Some(0), &reconstruction).is_err(),
                "derived reconstruction was accepted as an original occurrence"
            );
            std::fs::remove_file(source).unwrap();
            std::fs::remove_file(destination).unwrap();
        }
    }

    #[test]
    fn task_scoring_rejects_signed_return_overflow() {
        let mut spec = task_spec([0, 1, 1], vec![0]);
        spec.scoring.correct_weight = u32::MAX;
        spec.scoring.improvement_weight = u32::MAX;
        assert!(spec.validate_records(&carry_records()).is_err());
    }

    #[test]
    fn cold_task_binding_requires_admitted_statement_scope() {
        let spec = task_spec([0, 1, 1], vec![0]);
        spec.validate_records(&carry_records()).unwrap();
        for invalid in 0..4 {
            let mut records = carry_records();
            match invalid {
                0 => records.records[1].predicate = RelId(18),
                1 => records.records[1].predicate = RelId(999),
                2 => records.predicates[0].role = SemanticRecordRole::Qualifier,
                _ => records.supports[0].statement = 2,
            }
            assert!(spec.validate_records(&records).is_err(), "case {invalid}");
        }
        assert!(task_spec([0, 2, 2], vec![])
            .validate_records(&carry_records())
            .is_err());
        assert!(task_spec([0, 1, 1], vec![1])
            .validate_records(&carry_records())
            .is_err());
    }
}