eidetic-engine 0.15.2

use std::cmp::Ordering;
use std::collections::{BTreeMap, BTreeSet, BinaryHeap};
use std::fmt;
use std::sync::OnceLock;

use serde::{Serialize, Serializer};
use tiktoken_rs::{CoreBPE, cl100k_base};

use crate::cache::{CacheBudget, MemoryPressure, assess_pressure};
use crate::config::MeshCommandMode;
use crate::core::contradiction_guard::{GuardedMemory, decide_contradiction_survivor};
use crate::core::degraded_aggregation::{
    AggregatedDegradation, DegradationAggregationInput, aggregate_degraded_entries,
};
use crate::models::{
    COVERAGE_GAP_SCHEMA_V1, ContextProfile, ContextProfileName, ContextProfileSection,
    ContextProfileSectionMix, ERROR_SCHEMA_V2, EmbedBackend, MemoryId, MemoryScopeStats,
    ProvenanceUri, RESPONSE_SCHEMA_V1, RESPONSE_SCHEMA_V2, RedactionLevel, TrustClass, UnitScore,
};
use crate::runtime::determinism::{Deterministic, Seed};
use crate::util::radix_ulid_sort::sort_by_ulid_payload_or_lexical;

pub use crate::models::DegradationSeverity as ContextResponseSeverity;

pub mod binary;
pub mod budget_classifier;

pub const SUBSYSTEM: &str = "pack";
pub const PACK_COMMAND: &str = "pack";
pub const DEFAULT_CONTEXT_MAX_TOKENS: u32 = 4_000;
pub const DEFAULT_CANDIDATE_POOL: u32 = 64;
pub const DEFAULT_MMR_RELEVANCE_WEIGHT: f32 = 0.75;
pub const FACILITY_LOCATION_RELEVANCE_WEIGHT: f32 = 0.70;
pub const FACILITY_LOCATION_UTILITY_WEIGHT: f32 = 0.30;
pub const FACILITY_LOCATION_EPSILON: f32 = 0.000_001;
pub const DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR: f32 = 0.05;
pub const MAX_PACK_SKIPPED_ITEMS: usize = 50;
pub const COORDINATION_SNAPSHOT_SCHEMA_V1: &str = "ee.coordination_snapshot.v1";
pub const PACK_REVISION_TOKEN_SCHEMA_V1: &str = "ee.pack.revision_token.v1";
pub const PACK_ATTEMPT_FAMILY_MULTIPLICITY_SCHEMA_V1: &str =
    "ee.pack.attempt_family_multiplicity.v1";
pub const WHY_NOT_SELECTED_SCHEMA_V1: &str = "ee.why_not_selected.v1";
pub const DEFAULT_COORDINATION_STALE_AFTER_MS: u64 = 86_400_000;

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackRevisionMeshMetadata {
    pub schema: &'static str,
    pub mode: &'static str,
    pub token: String,
    pub tier1_usable: bool,
    pub revision_available: bool,
    pub reason: &'static str,
    pub query_hash: String,
    pub pack_hash: String,
    pub local_mesh_tip_state: PackRevisionMeshTipState,
    pub selected_memory_ids: Vec<String>,
    pub rebuild_command: String,
    pub diff_command: String,
}

impl PackRevisionMeshMetadata {
    #[must_use]
    pub fn for_context_response(
        response: &ContextResponse,
        mode: MeshCommandMode,
        surface_command: &str,
    ) -> Option<Self> {
        if mode != MeshCommandMode::Revisable {
            return None;
        }
        let query_hash = revision_hash_with_prefix(&["query", &response.data.request.query]);
        let pack_hash = response
            .data
            .pack
            .hash
            .clone()
            .unwrap_or_else(|| "absent".to_owned());
        let selected_memory_ids = response
            .data
            .pack
            .items
            .iter()
            .map(|item| item.memory_id.to_string())
            .collect::<Vec<_>>();
        let local_mesh_tip_state = PackRevisionMeshTipState::not_checked();
        let selected_fingerprint = selected_memory_ids.join("\n");
        let token_digest = revision_hash(&[
            PACK_REVISION_TOKEN_SCHEMA_V1,
            mode.as_str(),
            surface_command,
            &query_hash,
            &pack_hash,
            local_mesh_tip_state.status,
            local_mesh_tip_state.basis,
            &selected_fingerprint,
        ]);
        let token = format!("packrev_{}", &token_digest[..32]);
        let quoted_query = shell_quote(&response.data.request.query);
        Some(Self {
            schema: PACK_REVISION_TOKEN_SCHEMA_V1,
            mode: mode.as_str(),
            token: token.clone(),
            tier1_usable: true,
            revision_available: false,
            reason: "no_fresher_peer_material_known",
            query_hash,
            pack_hash: pack_hash.clone(),
            local_mesh_tip_state,
            selected_memory_ids,
            rebuild_command: format!("ee {surface_command} {quoted_query} --mesh revisable --json"),
            diff_command: format!("ee pack diff {pack_hash} {token}"),
        })
    }
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackRevisionMeshTipState {
    pub status: &'static str,
    pub basis: &'static str,
}

impl PackRevisionMeshTipState {
    #[must_use]
    pub const fn not_checked() -> Self {
        Self {
            status: "not_checked",
            basis: "no_async_peer_freshness_probe_attached",
        }
    }
}

pub(crate) fn revision_hash(parts: &[&str]) -> String {
    let mut hasher = blake3::Hasher::new();
    for part in parts {
        hasher.update((part.len() as u64).to_be_bytes().as_slice());
        hasher.update(part.as_bytes());
        hasher.update(&[0]);
    }
    hasher.finalize().to_hex().to_string()
}

pub(crate) fn revision_hash_with_prefix(parts: &[&str]) -> String {
    format!("blake3:{}", revision_hash(parts))
}

fn shell_quote(value: &str) -> String {
    if value.is_empty() {
        return "''".to_owned();
    }
    format!("'{}'", value.replace('\'', "'\"'\"'"))
}

/// bd-1prrl.7.3: Arena allocation policy for pack assembly scratch.
///
/// The enum names the lifetime contract so tracing fields and perf
/// fixtures can identify which allocation strategy produced a given
/// pack. `WorkspaceReuse` is available only through the explicit
/// [`PackArenaWorkspace`] API; ordinary assembly calls fall back to
/// disabled allocation when no workspace lifetime is supplied.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum ArenaMode {
    /// No arena indirection; standard `Vec` allocation per call.
    /// This is the public default and the baseline for parity tests.
    #[default]
    Disabled,
    /// Arena scratch is allocated and dropped within one pack
    /// assembly call. No reference into scratch outlives the call.
    RequestScoped,
    /// Scratch buffers are reset and reused across multiple pack
    /// assembly calls within one explicit workspace lifetime.
    WorkspaceReuse,
}

impl ArenaMode {
    /// Stable wire-name for tracing fields and perf artifacts.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Disabled => "disabled",
            Self::RequestScoped => "request_scoped",
            Self::WorkspaceReuse => "workspace_reuse",
        }
    }
}

/// bd-1prrl.7.3: Stable identifier for the arena allocation+reset
/// policy version. Bump only when reset, poisoning, or lifetime
/// behavior changes — pack content is independent of this value.
pub const ARENA_POLICY_VERSION: &str = "2";

pub const DEFAULT_ARENA_WORKSPACE_CAPACITY: usize = 4_096;

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackArenaWorkspaceKey {
    pub workspace: String,
    pub schema: &'static str,
    pub resource_profile: PackResourceProfile,
    pub arena_policy_version: &'static str,
}

impl PackArenaWorkspaceKey {
    #[must_use]
    pub fn new(workspace: impl Into<String>, resource_profile: PackResourceProfile) -> Self {
        Self {
            workspace: workspace.into(),
            schema: "ee.pack.v2",
            resource_profile,
            arena_policy_version: ARENA_POLICY_VERSION,
        }
    }

    #[must_use]
    pub fn generation_key(&self) -> String {
        revision_hash_with_prefix(&[
            "pack_arena_workspace",
            &self.workspace,
            self.schema,
            self.resource_profile.as_str(),
            self.arena_policy_version,
        ])
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PackArenaWorkspaceStats {
    pub fresh_scratch_allocations: u64,
    pub reset_count: u64,
    pub fallback_count: u64,
    pub max_candidate_capacity: usize,
    pub poisoned: bool,
    pub poison_reason: Option<&'static str>,
}

#[derive(Debug)]
pub struct PackArenaWorkspace {
    key: PackArenaWorkspaceKey,
    capacity_cap: usize,
    mmr_scratch: Option<MmrAssemblyScratch>,
    facility_scratch: Option<PackDraftScratch>,
    stats: PackArenaWorkspaceStats,
}

impl PackArenaWorkspace {
    #[must_use]
    pub fn new(key: PackArenaWorkspaceKey) -> Self {
        Self::with_capacity_cap(key, DEFAULT_ARENA_WORKSPACE_CAPACITY)
    }

    #[must_use]
    pub fn with_capacity_cap(key: PackArenaWorkspaceKey, capacity_cap: usize) -> Self {
        Self {
            key,
            capacity_cap,
            mmr_scratch: None,
            facility_scratch: None,
            stats: PackArenaWorkspaceStats::default(),
        }
    }

    #[must_use]
    pub fn generation_key(&self) -> String {
        self.key.generation_key()
    }

    #[must_use]
    pub const fn capacity_cap(&self) -> usize {
        self.capacity_cap
    }

    #[must_use]
    pub fn stats(&self) -> PackArenaWorkspaceStats {
        let mut stats = self.stats.clone();
        stats.poisoned = self.stats.poisoned;
        stats.poison_reason = self.stats.poison_reason;
        stats
    }

    #[must_use]
    pub const fn is_poisoned(&self) -> bool {
        self.stats.poisoned
    }

    fn poison(&mut self, reason: &'static str) {
        self.stats.poisoned = true;
        self.stats.poison_reason = Some(reason);
        self.mmr_scratch = None;
        self.facility_scratch = None;
    }

    fn can_reuse_candidate_capacity(&mut self, candidate_count: usize) -> bool {
        if self.stats.poisoned {
            self.stats.fallback_count = self.stats.fallback_count.saturating_add(1);
            return false;
        }
        if candidate_count > self.capacity_cap {
            self.poison("candidate_capacity_exceeded");
            self.stats.fallback_count = self.stats.fallback_count.saturating_add(1);
            return false;
        }
        self.stats.max_candidate_capacity = self.stats.max_candidate_capacity.max(candidate_count);
        true
    }

    fn take_mmr_scratch(&mut self, candidate_count: usize) -> Option<MmrAssemblyScratch> {
        if !self.can_reuse_candidate_capacity(candidate_count) {
            return None;
        }
        match self.mmr_scratch.take() {
            Some(mut scratch) => {
                scratch.reset_for_candidate_capacity(candidate_count);
                self.stats.reset_count = self.stats.reset_count.saturating_add(1);
                Some(scratch)
            }
            None => {
                self.stats.fresh_scratch_allocations =
                    self.stats.fresh_scratch_allocations.saturating_add(1);
                Some(MmrAssemblyScratch::with_candidate_capacity(candidate_count))
            }
        }
    }

    fn put_mmr_scratch(&mut self, mut scratch: MmrAssemblyScratch, candidate_count: usize) {
        scratch.reset_for_candidate_capacity(candidate_count);
        self.mmr_scratch = Some(scratch);
    }

    fn take_facility_scratch(&mut self, candidate_count: usize) -> Option<PackDraftScratch> {
        if !self.can_reuse_candidate_capacity(candidate_count) {
            return None;
        }
        match self.facility_scratch.take() {
            Some(mut scratch) => {
                scratch.reset_for_candidate_capacity(candidate_count);
                self.stats.reset_count = self.stats.reset_count.saturating_add(1);
                Some(scratch)
            }
            None => {
                self.stats.fresh_scratch_allocations =
                    self.stats.fresh_scratch_allocations.saturating_add(1);
                Some(PackDraftScratch::with_candidate_capacity(candidate_count))
            }
        }
    }

    fn put_facility_scratch(&mut self, mut scratch: PackDraftScratch, candidate_count: usize) {
        scratch.reset_for_candidate_capacity(candidate_count);
        self.facility_scratch = Some(scratch);
    }
}

/// bd-1prrl.7.3: RAII lifetime guard for one arena scope (one pack
/// assembly request). Owning the guard on the assembly stack frame
/// ties scratch lifetime to the function call; on drop, an audit
/// trace records the scope close so reset-count and reuse-generation
/// counters in bd-1prrl.7.5 perf fixtures have a single emission
/// point. Does not own scratch buffers itself — Rust ownership of
/// `PackDraftScratch` / `MmrAssemblyScratch` is the actual guarantee.
struct ArenaScope {
    mode: ArenaMode,
    reuse_generation: Option<String>,
}

impl ArenaScope {
    fn new(mode: ArenaMode, reuse_generation: Option<String>) -> Self {
        tracing::trace!(
            target: "ee::pack::arena",
            arena_mode = mode.as_str(),
            arena_policy_version = ARENA_POLICY_VERSION,
            arena_reuse_generation = reuse_generation.as_deref(),
            event = "scope_open",
            "arena scope opened for pack assembly"
        );
        Self {
            mode,
            reuse_generation,
        }
    }
}

impl Drop for ArenaScope {
    fn drop(&mut self) {
        tracing::trace!(
            target: "ee::pack::arena",
            arena_mode = self.mode.as_str(),
            arena_policy_version = ARENA_POLICY_VERSION,
            arena_reuse_generation = self.reuse_generation.as_deref(),
            event = "scope_close",
            arena_reset_count = 1u32,
            "arena scope closed; scratch dropped within request"
        );
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PackLodBudgetShares {
    pub full_basis_points: u16,
    pub truncated_preview_basis_points: u16,
    pub link_only_basis_points: u16,
}

impl PackLodBudgetShares {
    #[must_use]
    pub const fn new(
        full_basis_points: u16,
        truncated_preview_basis_points: u16,
        link_only_basis_points: u16,
    ) -> Self {
        Self {
            full_basis_points,
            truncated_preview_basis_points,
            link_only_basis_points,
        }
    }

    #[must_use]
    pub const fn default_70_20_10() -> Self {
        Self::new(7_000, 2_000, 1_000)
    }

    fn limits(self, budget: TokenBudget) -> PackLodBudgetLimits {
        let total = u32::from(self.full_basis_points)
            .saturating_add(u32::from(self.truncated_preview_basis_points))
            .saturating_add(u32::from(self.link_only_basis_points));
        if total == 0 {
            return PackLodBudgetLimits::full_only(budget.max_tokens());
        }

        let max_tokens = budget.max_tokens();
        let full = lod_share_tokens(max_tokens, self.full_basis_points, total).min(max_tokens);
        let remaining_after_full = max_tokens.saturating_sub(full);
        let truncated_preview =
            lod_share_tokens(max_tokens, self.truncated_preview_basis_points, total)
                .min(remaining_after_full);
        let remaining_after_preview = remaining_after_full.saturating_sub(truncated_preview);
        let link_only = lod_share_tokens(max_tokens, self.link_only_basis_points, total)
            .min(remaining_after_preview);

        PackLodBudgetLimits {
            full,
            truncated_preview,
            link_only,
        }
    }
}

impl Default for PackLodBudgetShares {
    fn default() -> Self {
        Self::default_70_20_10()
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PackAssemblyOptions {
    pub include_coverage_fill: bool,
    pub include_anti_pattern_first: bool,
    pub output_redaction_enabled: bool,
    pub redaction_level: RedactionLevel,
    /// Budget shares for level-of-detail pack rendering.
    ///
    /// `Some` enables the default bd-1n0np.5.1 behavior: selected
    /// candidates first consume full-content budget, then deterministic
    /// preview budget, then compact link-only budget. `None` preserves
    /// the pre-LOD single-tier budget policy for tests that need an
    /// exact historical baseline.
    pub lod_budget_shares: Option<PackLodBudgetShares>,
    /// bd-1prrl.7.3: Arena allocation strategy for scratch buffers.
    /// Defaults to [`ArenaMode::Disabled`] so existing public output
    /// is unchanged. Does not participate in `compute_pack_hash`
    /// inputs, omission order, or selection audit content — those
    /// invariants are preserved across arena modes by contract
    /// (`docs/pack-arena-assembly.md`).
    pub arena_mode: ArenaMode,
}

impl Default for PackAssemblyOptions {
    fn default() -> Self {
        Self {
            include_coverage_fill: true,
            include_anti_pattern_first: true,
            output_redaction_enabled: true,
            redaction_level: RedactionLevel::Minimal,
            lod_budget_shares: Some(PackLodBudgetShares::default()),
            arena_mode: ArenaMode::Disabled,
        }
    }
}

/// Compact coordination posture embedded in context packs.
///
/// The snapshot is intentionally source-agnostic and side-effect free. It is
/// loaded from a caller-provided JSON file so pack assembly can stay
/// deterministic and avoid requiring a live Agent Mail server.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackCoordinationSnapshot {
    pub schema: &'static str,
    pub captured_at: Option<String>,
    pub scope: String,
    pub freshness: PackCoordinationFreshness,
    pub summary: PackCoordinationSummary,
    pub sources: Vec<PackCoordinationSource>,
}

impl PackCoordinationSnapshot {
    /// Parse a redacted coordination snapshot from JSON.
    ///
    /// # Errors
    ///
    /// Returns a stable message when the JSON cannot be parsed or does not
    /// contain a `sources[]` array compatible with `ee.coordination_snapshot.v1`.
    pub fn from_json_str(input: &str, stale_after_ms: u64) -> Result<Self, String> {
        let root = serde_json::from_str::<serde_json::Value>(input)
            .map_err(|error| format!("Coordination snapshot JSON could not be parsed: {error}"))?;
        let value = coordination_payload_value(&root);
        let schema = coordination_string_field(value, &["schema"]).unwrap_or_default();
        if !schema.is_empty() && schema != COORDINATION_SNAPSHOT_SCHEMA_V1 {
            return Err(format!(
                "Unsupported coordination snapshot schema `{schema}`; expected {COORDINATION_SNAPSHOT_SCHEMA_V1}."
            ));
        }
        let source_values = value
            .get("sources")
            .and_then(serde_json::Value::as_array)
            .ok_or_else(|| "Coordination snapshot is missing sources[].".to_owned())?;
        let mut sources = source_values
            .iter()
            .enumerate()
            .map(|(index, source)| parse_coordination_source(source, index, stale_after_ms))
            .collect::<Vec<_>>();
        sources.sort();
        sources.dedup();

        let summary = PackCoordinationSummary::from_sources(&sources);
        let freshness = PackCoordinationFreshness {
            status: coordination_overall_status(&summary).to_owned(),
            stale_after_ms,
        };

        Ok(Self {
            schema: COORDINATION_SNAPSHOT_SCHEMA_V1,
            captured_at: coordination_string_field(value, &["captured_at", "capturedAt"]),
            scope: coordination_string_field(value, &["scope"])
                .unwrap_or_else(|| "workspace".to_owned()),
            freshness,
            summary,
            sources,
        })
    }

    #[must_use]
    pub fn active_conflict_entries(&self) -> Vec<&PackCoordinationEntry> {
        self.sources
            .iter()
            .flat_map(|source| source.entries.iter())
            .filter(|entry| entry.conflict)
            .collect()
    }

    #[must_use]
    pub fn notable_entries(&self) -> Vec<&PackCoordinationEntry> {
        self.sources
            .iter()
            .flat_map(|source| source.entries.iter())
            .filter(|entry| {
                entry.conflict
                    || entry.kind == "file_reservation"
                    || entry.status.as_deref() == Some("in_progress")
            })
            .collect()
    }
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackCoordinationFreshness {
    pub status: String,
    pub stale_after_ms: u64,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackCoordinationSummary {
    pub source_count: usize,
    pub entry_count: usize,
    pub stale_source_count: usize,
    pub degraded_source_count: usize,
    pub unavailable_source_count: usize,
    pub active_conflict_count: usize,
    pub active_reservation_count: usize,
    pub in_progress_bead_count: usize,
}

impl PackCoordinationSummary {
    #[must_use]
    pub fn from_sources(sources: &[PackCoordinationSource]) -> Self {
        let mut summary = Self {
            source_count: sources.len(),
            entry_count: 0,
            stale_source_count: 0,
            degraded_source_count: 0,
            unavailable_source_count: 0,
            active_conflict_count: 0,
            active_reservation_count: 0,
            in_progress_bead_count: 0,
        };
        for source in sources {
            summary.entry_count = summary.entry_count.saturating_add(source.entries.len());
            if source.stale {
                summary.stale_source_count = summary.stale_source_count.saturating_add(1);
            }
            if matches!(
                source.status.as_str(),
                "degraded" | "unavailable" | "not_configured" | "skipped"
            ) || !source.degraded.is_empty()
            {
                summary.degraded_source_count = summary.degraded_source_count.saturating_add(1);
            }
            if matches!(
                source.status.as_str(),
                "unavailable" | "not_configured" | "skipped"
            ) {
                summary.unavailable_source_count =
                    summary.unavailable_source_count.saturating_add(1);
            }
            for entry in &source.entries {
                if entry.conflict {
                    summary.active_conflict_count = summary.active_conflict_count.saturating_add(1);
                }
                if entry.kind == "file_reservation" {
                    summary.active_reservation_count =
                        summary.active_reservation_count.saturating_add(1);
                }
                if entry.kind == "bead" && entry.status.as_deref() == Some("in_progress") {
                    summary.in_progress_bead_count =
                        summary.in_progress_bead_count.saturating_add(1);
                }
            }
        }
        summary
    }
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackCoordinationSource {
    pub kind: String,
    pub source_id: String,
    pub status: String,
    pub freshness_ms: Option<u64>,
    pub last_synced_at: Option<String>,
    pub stale: bool,
    pub entry_count: usize,
    pub entries: Vec<PackCoordinationEntry>,
    #[serde(serialize_with = "serialize_pack_coordination_degraded")]
    pub degraded: Vec<PackCoordinationDegradation>,
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackCoordinationEntry {
    pub kind: String,
    pub id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    pub summary: String,
    pub severity: String,
    pub conflict: bool,
    pub provenance: Vec<String>,
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackCoordinationDegradation {
    pub code: String,
    pub severity: String,
    pub message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub repair: Option<String>,
}

fn serialize_pack_coordination_degraded<S>(
    degraded: &[PackCoordinationDegradation],
    serializer: S,
) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    aggregate_pack_coordination_degraded(degraded).serialize(serializer)
}

fn aggregate_pack_coordination_degraded(
    degraded: &[PackCoordinationDegradation],
) -> Vec<AggregatedDegradation> {
    aggregate_degraded_entries(degraded.iter().map(|entry| {
        DegradationAggregationInput::new(
            "pack_coordination",
            entry.code.clone(),
            entry.severity.clone(),
            entry.message.clone(),
            entry
                .repair
                .clone()
                .unwrap_or_else(|| "Review coordination source diagnostics.".to_owned()),
        )
    }))
}

fn coordination_payload_value(root: &serde_json::Value) -> &serde_json::Value {
    match root.get("schema").and_then(serde_json::Value::as_str) {
        Some(schema) if schema == RESPONSE_SCHEMA_V1 || schema == RESPONSE_SCHEMA_V2 => {
            root.get("data").unwrap_or(root)
        }
        _ => root,
    }
}

fn parse_coordination_source(
    value: &serde_json::Value,
    index: usize,
    stale_after_ms: u64,
) -> PackCoordinationSource {
    let kind = coordination_string_field(value, &["kind", "source"])
        .unwrap_or_else(|| format!("source_{index}"));
    let source_id = coordination_string_field(value, &["source_id", "sourceId", "id"])
        .unwrap_or_else(|| kind.clone());
    let freshness_ms = coordination_u64_field(value, &["freshness_ms", "freshnessMs"])
        .or_else(|| {
            value
                .get("freshness")
                .and_then(|freshness| coordination_u64_field(freshness, &["age_ms", "ageMs"]))
        })
        .or_else(|| {
            value
                .get("freshness")
                .and_then(|freshness| {
                    coordination_u64_field(freshness, &["age_seconds", "ageSeconds"])
                })
                .map(|seconds| seconds.saturating_mul(1_000))
        });
    let explicitly_stale = coordination_bool_field(value, &["stale"]).unwrap_or(false);
    let status_field =
        coordination_string_field(value, &["status"]).map(|status| status.to_ascii_lowercase());
    let stale = explicitly_stale
        || freshness_ms.is_some_and(|age| age > stale_after_ms)
        || status_field.as_deref() == Some("stale");
    let mut entries = value
        .get("entries")
        .and_then(serde_json::Value::as_array)
        .map(|items| {
            items
                .iter()
                .enumerate()
                .map(|(entry_index, entry)| {
                    parse_coordination_entry(entry, &kind, &source_id, entry_index)
                })
                .collect::<Vec<_>>()
        })
        .unwrap_or_default();
    entries.sort();
    entries.dedup();

    let mut degraded = parse_coordination_degradations(value);
    degraded.sort();
    degraded.dedup();
    let status = status_field.unwrap_or_else(|| {
        if !degraded.is_empty() {
            "degraded".to_owned()
        } else if stale {
            "stale".to_owned()
        } else {
            "fresh".to_owned()
        }
    });

    PackCoordinationSource {
        kind,
        source_id,
        status,
        freshness_ms,
        last_synced_at: coordination_string_field(value, &["last_synced_at", "lastSyncedAt"]),
        stale,
        entry_count: entries.len(),
        entries,
        degraded,
    }
}

fn parse_coordination_entry(
    value: &serde_json::Value,
    source_kind: &str,
    source_id: &str,
    index: usize,
) -> PackCoordinationEntry {
    let kind = coordination_string_field(value, &["kind"])
        .unwrap_or_else(|| coordination_entry_kind_from_source(source_kind));
    let id = coordination_string_field(
        value,
        &[
            "id",
            "bead_id",
            "beadId",
            "thread_id",
            "threadId",
            "path_pattern",
            "pathPattern",
            "path",
            "mailbox",
        ],
    )
    .unwrap_or_else(|| format!("{source_id}:{index}"));
    let status = coordination_string_field(value, &["status"]);
    let conflict = coordination_bool_field(value, &["conflict", "activeConflict"]).unwrap_or(false);
    let severity = coordination_string_field(value, &["severity"]).unwrap_or_else(|| {
        if conflict {
            "warning".to_owned()
        } else {
            "info".to_owned()
        }
    });
    let provenance = coordination_provenance(value).unwrap_or_else(|| vec![source_id.to_owned()]);
    PackCoordinationEntry {
        summary: coordination_entry_summary(value, &kind, &id),
        kind,
        id,
        status,
        severity,
        conflict,
        provenance,
    }
}

fn coordination_entry_kind_from_source(source_kind: &str) -> String {
    if source_kind.contains("reservation") {
        "file_reservation".to_owned()
    } else if source_kind.contains("bead") {
        "bead".to_owned()
    } else if source_kind.contains("thread") || source_kind.contains("mail") {
        "agent_mail_thread".to_owned()
    } else {
        source_kind.to_owned()
    }
}

fn coordination_entry_summary(value: &serde_json::Value, kind: &str, id: &str) -> String {
    if let Some(summary) = coordination_string_field(value, &["summary", "title", "subject"]) {
        return summary;
    }
    if kind == "file_reservation" {
        let path = coordination_string_field(value, &["path_pattern", "pathPattern", "path"])
            .unwrap_or_else(|| id.to_owned());
        let holder = coordination_string_field(value, &["holder", "agent", "agent_name"]);
        let exclusive = coordination_bool_field(value, &["exclusive"]).unwrap_or(false);
        return match holder {
            Some(holder) if exclusive => {
                format!("exclusive reservation on {path} held by {holder}")
            }
            Some(holder) => format!("reservation on {path} held by {holder}"),
            None if exclusive => format!("exclusive reservation on {path}"),
            None => format!("reservation on {path}"),
        };
    }
    id.to_owned()
}

fn parse_coordination_degradations(value: &serde_json::Value) -> Vec<PackCoordinationDegradation> {
    value
        .get("degraded")
        .or_else(|| value.get("degradations"))
        .and_then(serde_json::Value::as_array)
        .map(|items| {
            items
                .iter()
                .enumerate()
                .map(|(index, item)| PackCoordinationDegradation {
                    code: coordination_string_field(item, &["code"])
                        .unwrap_or_else(|| format!("coordination_source_degraded_{index}")),
                    severity: coordination_string_field(item, &["severity"])
                        .unwrap_or_else(|| "warning".to_owned()),
                    message: coordination_string_field(item, &["message"])
                        .unwrap_or_else(|| "Coordination source is degraded.".to_owned()),
                    repair: coordination_string_field(item, &["repair"]),
                })
                .collect()
        })
        .unwrap_or_default()
}

fn coordination_string_field(value: &serde_json::Value, keys: &[&str]) -> Option<String> {
    keys.iter().find_map(|key| {
        value
            .get(*key)
            .and_then(serde_json::Value::as_str)
            .map(ToOwned::to_owned)
    })
}

fn coordination_u64_field(value: &serde_json::Value, keys: &[&str]) -> Option<u64> {
    keys.iter()
        .find_map(|key| value.get(*key).and_then(serde_json::Value::as_u64))
}

fn coordination_bool_field(value: &serde_json::Value, keys: &[&str]) -> Option<bool> {
    keys.iter()
        .find_map(|key| value.get(*key).and_then(serde_json::Value::as_bool))
}

fn coordination_provenance(value: &serde_json::Value) -> Option<Vec<String>> {
    match value.get("provenance") {
        Some(serde_json::Value::Array(items)) => {
            let provenance = items
                .iter()
                .filter_map(serde_json::Value::as_str)
                .map(ToOwned::to_owned)
                .collect::<Vec<_>>();
            (!provenance.is_empty()).then_some(provenance)
        }
        Some(serde_json::Value::String(item)) => Some(vec![item.clone()]),
        _ => None,
    }
}

fn coordination_overall_status(summary: &PackCoordinationSummary) -> &'static str {
    if summary.unavailable_source_count > 0 || summary.degraded_source_count > 0 {
        "degraded"
    } else if summary.stale_source_count > 0 {
        "stale"
    } else if summary.active_conflict_count > 0 {
        "conflict"
    } else {
        "fresh"
    }
}

/// Similarity floor applied when two candidates share the same `diversity_key`
/// during facility-location selection.
///
/// Two candidates tagged with the same coarse diversity bucket (e.g. both
/// labelled `formatting`) are treated as substantially redundant: at 0.85 they
/// score above the typical Jaccard content-overlap of unrelated text but below
/// the 1.0 floor reserved for an exact memory_id or normalized-content match.
/// This biases the greedy facility-location picker toward broader bucket
/// coverage without claiming the two candidates are duplicates outright (in
/// which case the regular content-overlap calculation can still pull the
/// score higher if the texts genuinely overlap).
pub const FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR: f32 = 0.85;
pub const PACK_ITEM_PROVENANCE_SCHEMA_V1: &str = "ee.pack_item.provenance.v1";

fn serialize_pack_json_or_error<T>(
    value: &T,
    type_name: &str,
    expected_schema: Option<&str>,
) -> String
where
    T: Serialize,
{
    match serde_json::to_string(value) {
        Ok(json) => json,
        Err(error) => serde_json::json!({
            "schema": ERROR_SCHEMA_V2,
            "error": {
                "code": "serialization_failed",
                "message": format!("Failed to serialize {type_name} as JSON."),
                "severity": "high",
                "repair": "Fix the pack serializer; refusing to emit an empty object.",
                "details": {
                    "type": type_name,
                    "expectedSchema": expected_schema,
                    "serializerError": error.to_string(),
                }
            }
        })
        .to_string(),
    }
}

/// Conservative characters-per-token ratio for the legacy character
/// heuristic. Uses 3.5 instead of 4.0 to bias toward overestimation.
///
/// Retained for the explicit `CharacterHeuristic` fallback strategy. The
/// default token estimator no longer uses this constant — see
/// `TokenEstimationStrategy::TiktokenCl100kBase`.
pub const DEFAULT_CHARS_PER_TOKEN: f32 = 3.5;
const CHARACTER_HEURISTIC_CHARS_PER_TOKEN_NUMERATOR: u64 = 7;
const CHARACTER_HEURISTIC_CHARS_PER_TOKEN_DENOMINATOR: u64 = 2;
const WORD_HEURISTIC_TOKEN_MULTIPLIER_NUMERATOR: u64 = 13;
const WORD_HEURISTIC_TOKEN_MULTIPLIER_DENOMINATOR: u64 = 10;

/// Process-wide cache for the cl100k_base BPE encoder. The encoder is
/// expensive to construct (loads embedded merge tables) and immutable once
/// built, so a single instance is reused across all callers.
///
/// The cache is `Option<CoreBPE>` rather than `CoreBPE` so a failure to
/// initialize the embedded tables (which would indicate a corrupt build
/// artifact) degrades to the character heuristic instead of panicking
/// from inside a budget calculation.
static CL100K_BASE: OnceLock<Option<CoreBPE>> = OnceLock::new();

/// Borrow the shared cl100k_base encoder, initializing on first use.
/// Returns `None` only if tiktoken-rs's embedded BPE tables fail to load,
/// in which case `estimate_tokens` falls back to the character heuristic.
fn cl100k_base_encoder() -> Option<&'static CoreBPE> {
    CL100K_BASE
        .get_or_init(|| match cl100k_base() {
            Ok(encoder) => Some(encoder),
            Err(error) => {
                tracing::error!(
                    target: "ee::pack::tokenizer",
                    error = %error,
                    "tiktoken-rs cl100k_base failed to initialize; pack token \
                     estimation is falling back to the character heuristic"
                );
                None
            }
        })
        .as_ref()
}

fn estimate_character_heuristic_tokens(char_count: u64) -> u32 {
    if char_count == 0 {
        return 0;
    }

    let estimate = char_count
        .saturating_mul(CHARACTER_HEURISTIC_CHARS_PER_TOKEN_DENOMINATOR)
        .div_ceil(CHARACTER_HEURISTIC_CHARS_PER_TOKEN_NUMERATOR);
    u32::try_from(estimate.max(1)).unwrap_or(u32::MAX)
}

fn estimate_word_heuristic_tokens(word_count: u64) -> u32 {
    if word_count == 0 {
        return 0;
    }

    let estimate = word_count
        .saturating_mul(WORD_HEURISTIC_TOKEN_MULTIPLIER_NUMERATOR)
        .div_ceil(WORD_HEURISTIC_TOKEN_MULTIPLIER_DENOMINATOR);
    u32::try_from(estimate.max(1)).unwrap_or(u32::MAX)
}

/// Token estimation strategy (EE-143, eidetic_engine_cli-aitk).
///
/// The default is real BPE counting via `tiktoken-rs`'s `cl100k_base`
/// encoder — the same encoder OpenAI's GPT-3.5 / GPT-4 family uses. The
/// character and word heuristics remain available as explicit fallbacks
/// for callers who need a faster (~zero-allocation) approximation and
/// can tolerate the bias bands documented on each variant.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub enum TokenEstimationStrategy {
    /// Real BPE counting using the cl100k_base encoder shared across the
    /// process. Authoritative for context budget enforcement: matches the
    /// token count that GPT-3.5 / GPT-4 family models would actually see.
    #[default]
    TiktokenCl100kBase,
    /// Character-count divided by `DEFAULT_CHARS_PER_TOKEN` (3.5).
    /// Fast and allocation-free but biased: undercounts CJK by roughly
    /// 3-4x and miscounts code/JSON with many short tokens.
    CharacterHeuristic,
    /// Whitespace-separated word count, multiplied by 1.3.
    /// More accurate for prose; still biased for code and CJK content.
    WordHeuristic,
}

impl TokenEstimationStrategy {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::TiktokenCl100kBase => "tiktoken_cl100k_base",
            Self::CharacterHeuristic => "character_heuristic",
            Self::WordHeuristic => "word_heuristic",
        }
    }

    #[must_use]
    pub const fn all() -> [Self; 3] {
        [
            Self::TiktokenCl100kBase,
            Self::CharacterHeuristic,
            Self::WordHeuristic,
        ]
    }
}

impl fmt::Display for TokenEstimationStrategy {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// Estimate the number of tokens in the given text.
///
/// The default strategy (`TiktokenCl100kBase`) returns the exact BPE
/// token count GPT-3.5/4-class models would see. The heuristic strategies
/// remain available for callers that need an allocation-free estimate
/// and can tolerate the documented bias.
///
/// Returns at least 1 for any non-empty trimmed input regardless of
/// strategy, so callers can use the result as a budget floor.
#[must_use]
pub fn estimate_tokens(content: &str, strategy: TokenEstimationStrategy) -> u32 {
    let trimmed = content.trim();
    if trimmed.is_empty() {
        return 0;
    }

    match strategy {
        TokenEstimationStrategy::TiktokenCl100kBase => {
            if let Some(encoder) = cl100k_base_encoder() {
                let count = encoder.encode_with_special_tokens(trimmed).len();
                u32::try_from(count).unwrap_or(u32::MAX).max(1)
            } else {
                // Embedded BPE tables failed to load; the warning was
                // already emitted on first init. Fall back to the
                // character heuristic so budget enforcement still runs.
                estimate_character_heuristic_tokens(usize_to_u64(trimmed.chars().count()))
            }
        }
        TokenEstimationStrategy::CharacterHeuristic => {
            // Divide by chars-per-token, round up for conservatism.
            estimate_character_heuristic_tokens(usize_to_u64(trimmed.chars().count()))
        }
        TokenEstimationStrategy::WordHeuristic => {
            // Multiply by 1.3 to account for punctuation and subword tokens.
            estimate_word_heuristic_tokens(usize_to_u64(trimmed.split_whitespace().count()))
        }
    }
}

/// Estimate tokens using the default tokenizer-backed strategy.
#[must_use]
pub fn estimate_tokens_default(content: &str) -> u32 {
    estimate_tokens(content, TokenEstimationStrategy::default())
}

#[must_use]
pub const fn subsystem_name() -> &'static str {
    SUBSYSTEM
}

pub type ContextPackProfile = ContextProfileName;

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum PackSection {
    ProceduralRules,
    Decisions,
    Failures,
    Evidence,
    Artifacts,
}

impl PackSection {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::ProceduralRules => "procedural_rules",
            Self::Decisions => "decisions",
            Self::Failures => "failures",
            Self::Evidence => "evidence",
            Self::Artifacts => "artifacts",
        }
    }

    #[must_use]
    pub const fn all() -> [Self; 5] {
        [
            Self::ProceduralRules,
            Self::Decisions,
            Self::Failures,
            Self::Evidence,
            Self::Artifacts,
        ]
    }
}

impl fmt::Display for PackSection {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// Token quota for a single section (EE-144).
///
/// Quotas define soft limits on how many tokens a section can use.
/// When a section exceeds its max, remaining candidates are omitted
/// even if the overall budget has room.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct SectionQuota {
    /// Minimum tokens to reserve for this section (0 = no minimum).
    pub min_tokens: u32,
    /// Maximum tokens this section can use (0 = unlimited).
    pub max_tokens: u32,
}

impl SectionQuota {
    /// Create a quota with explicit min and max.
    #[must_use]
    pub const fn new(min_tokens: u32, max_tokens: u32) -> Self {
        Self {
            min_tokens,
            max_tokens,
        }
    }

    /// Create an unlimited quota (no constraints).
    #[must_use]
    pub const fn unlimited() -> Self {
        Self {
            min_tokens: 0,
            max_tokens: 0,
        }
    }

    /// Create a quota with only a maximum.
    #[must_use]
    pub const fn capped(max_tokens: u32) -> Self {
        Self {
            min_tokens: 0,
            max_tokens,
        }
    }

    /// Create a quota that disables the section entirely (zero capacity).
    ///
    /// The `{min_tokens:1, max_tokens:0}` shape is the disabled sentinel
    /// — bit-distinct from [`Self::unlimited`]'s `{0, 0}`, so consumers
    /// that branch on `max_tokens == 0` for the unlimited case can no
    /// longer collide with a `quota_for_basis_points(_, 0)` result
    /// (bd-2s2mv).
    #[must_use]
    pub const fn disabled() -> Self {
        Self {
            min_tokens: 1,
            max_tokens: 0,
        }
    }

    /// True if this quota has no constraints.
    #[must_use]
    pub const fn is_unlimited(self) -> bool {
        self.min_tokens == 0 && self.max_tokens == 0
    }

    /// True if this quota explicitly disables the section.
    #[must_use]
    pub const fn is_disabled(self) -> bool {
        self.min_tokens > 0 && self.max_tokens == 0
    }

    /// Check if a token count exceeds this quota's maximum.
    #[must_use]
    pub const fn exceeds_max(self, tokens: u32) -> bool {
        if self.is_disabled() {
            return tokens > 0;
        }
        self.max_tokens > 0 && tokens > self.max_tokens
    }

    /// Calculate remaining tokens allowed by this quota.
    #[must_use]
    pub const fn remaining(self, used: u32) -> u32 {
        if self.is_disabled() {
            return 0;
        }
        if self.max_tokens == 0 {
            u32::MAX
        } else {
            self.max_tokens.saturating_sub(used)
        }
    }
}

impl Default for SectionQuota {
    fn default() -> Self {
        Self::unlimited()
    }
}

/// Section quotas for context packing (EE-144).
///
/// Quotas control token allocation across sections, ensuring diversity
/// in the final pack. Each section can have independent min/max limits.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SectionQuotas {
    quotas: [SectionQuota; 5],
}

impl SectionQuotas {
    /// Create quotas with explicit values for each section.
    #[must_use]
    pub const fn new(
        procedural_rules: SectionQuota,
        decisions: SectionQuota,
        failures: SectionQuota,
        evidence: SectionQuota,
        artifacts: SectionQuota,
    ) -> Self {
        Self {
            quotas: [procedural_rules, decisions, failures, evidence, artifacts],
        }
    }

    /// Create quotas where all sections are unlimited.
    #[must_use]
    pub const fn unlimited() -> Self {
        Self {
            quotas: [SectionQuota::unlimited(); 5],
        }
    }

    /// Create quotas from a context profile section mix.
    #[must_use]
    pub fn from_section_mix(section_mix: ContextProfileSectionMix, total_budget: u32) -> Self {
        Self::new(
            quota_for_basis_points(
                total_budget,
                section_mix.weight_bps(ContextProfileSection::ProceduralRules),
            ),
            quota_for_basis_points(
                total_budget,
                section_mix.weight_bps(ContextProfileSection::Decisions),
            ),
            quota_for_basis_points(
                total_budget,
                section_mix.weight_bps(ContextProfileSection::Failures),
            ),
            quota_for_basis_points(
                total_budget,
                section_mix.weight_bps(ContextProfileSection::Evidence),
            ),
            quota_for_basis_points(
                total_budget,
                section_mix.weight_bps(ContextProfileSection::Artifacts),
            ),
        )
    }

    /// Create balanced quotas based on total budget and profile.
    ///
    /// Balanced profile allocates roughly:
    /// - ProceduralRules: 30%
    /// - Decisions: 20%
    /// - Failures: 20%
    /// - Evidence: 20%
    /// - Artifacts: 10%
    #[must_use]
    pub fn balanced(total_budget: u32) -> Self {
        Self::for_profile(ContextPackProfile::Balanced, total_budget)
    }

    /// Create compact quotas that prioritize procedural rules.
    ///
    /// Compact profile allocates:
    /// - ProceduralRules: 50%
    /// - Decisions: 15%
    /// - Failures: 20%
    /// - Evidence: 10%
    /// - Artifacts: 5%
    #[must_use]
    pub fn compact(total_budget: u32) -> Self {
        Self::for_profile(ContextPackProfile::Compact, total_budget)
    }

    /// Create thorough quotas with more even distribution.
    ///
    /// Thorough profile allocates:
    /// - ProceduralRules: 20%
    /// - Decisions: 20%
    /// - Failures: 20%
    /// - Evidence: 25%
    /// - Artifacts: 15%
    #[must_use]
    pub fn thorough(total_budget: u32) -> Self {
        Self::for_profile(ContextPackProfile::Thorough, total_budget)
    }

    /// Get quotas based on profile and budget.
    #[must_use]
    pub fn for_profile(profile: ContextPackProfile, total_budget: u32) -> Self {
        let profile = ContextProfile::builtin(profile);
        Self::from_section_mix(profile.section_mix, total_budget)
    }

    /// Get the quota for a specific section.
    #[must_use]
    pub const fn get(&self, section: PackSection) -> SectionQuota {
        self.quotas[section as usize]
    }

    /// Check if a section has room for more tokens.
    #[must_use]
    pub const fn has_room(&self, section: PackSection, used: u32, candidate_tokens: u32) -> bool {
        let quota = self.get(section);
        if quota.is_disabled() {
            return false;
        }
        if quota.is_unlimited() {
            return true;
        }
        match used.checked_add(candidate_tokens) {
            Some(total) => total <= quota.max_tokens,
            None => false,
        }
    }

    /// Get remaining tokens for a section.
    #[must_use]
    pub const fn remaining(&self, section: PackSection, used: u32) -> u32 {
        self.get(section).remaining(used)
    }
}

impl Default for SectionQuotas {
    fn default() -> Self {
        Self::unlimited()
    }
}

fn quota_for_basis_points(total_budget: u32, basis_points: u16) -> SectionQuota {
    if basis_points == 0 {
        // bd-2s2mv: 0 basis_points means "section disabled" — matches
        // `minimal_budget_for_section`'s u32::MAX sentinel for the same
        // input. Without this branch, `capped(0)` would collide with
        // `unlimited()` and silently admit every candidate in this
        // section up to the overall budget.
        return SectionQuota::disabled();
    }
    let product = u64::from(total_budget) * u64::from(basis_points);
    // `.max(1)` defends the same disambiguation: if `total_budget` and
    // `basis_points` are both small enough that the integer ceiling
    // collapses to zero, we want to keep at least one token of capacity
    // rather than tip back into the unlimited sentinel.
    let tokens = product.div_ceil(10_000).min(u64::from(u32::MAX)).max(1);
    SectionQuota::capped(tokens as u32)
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ContextRequestInput {
    pub query: String,
    pub profile: Option<ContextPackProfile>,
    pub max_tokens: Option<u32>,
    pub candidate_pool: Option<u32>,
    pub max_results: Option<u32>,
    pub sections: Vec<PackSection>,
}

impl ContextRequestInput {
    #[must_use]
    pub fn for_query(query: impl Into<String>) -> Self {
        Self {
            query: query.into(),
            profile: None,
            max_tokens: None,
            candidate_pool: None,
            max_results: None,
            sections: Vec::new(),
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ContextRequest {
    pub query: String,
    pub profile: ContextPackProfile,
    pub budget: TokenBudget,
    pub candidate_pool: u32,
    pub max_results: Option<u32>,
    pub sections: Vec<PackSection>,
}

impl ContextRequest {
    /// Build a validated context-pack request with stable defaults.
    ///
    /// # Errors
    ///
    /// Returns [`PackValidationError::EmptyQuery`] when the query is
    /// empty, [`PackValidationError::ZeroTokenBudget`] when
    /// `max_tokens` is zero, or
    /// [`PackValidationError::ZeroCandidatePool`] when the candidate
    /// pool is zero.
    pub fn new(input: ContextRequestInput) -> Result<Self, PackValidationError> {
        let query = trim_required(input.query, PackValidationError::EmptyQuery)?;
        let budget = match input.max_tokens {
            Some(max_tokens) => TokenBudget::new(max_tokens)?,
            None => TokenBudget::default_context(),
        };
        let candidate_pool = input.candidate_pool.unwrap_or(DEFAULT_CANDIDATE_POOL);
        if candidate_pool == 0 {
            return Err(PackValidationError::ZeroCandidatePool);
        }
        if input.max_results == Some(0) {
            return Err(PackValidationError::ZeroMaxResults);
        }
        let sections = if input.sections.is_empty() {
            PackSection::all().to_vec()
        } else {
            input.sections
        };

        Ok(Self {
            query,
            profile: input.profile.unwrap_or(ContextPackProfile::Balanced),
            budget,
            candidate_pool,
            max_results: input.max_results,
            sections,
        })
    }

    pub fn from_query(query: impl Into<String>) -> Result<Self, PackValidationError> {
        Self::new(ContextRequestInput::for_query(query))
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct TokenBudget {
    max_tokens: u32,
}

impl TokenBudget {
    /// Construct a non-zero token budget.
    ///
    /// # Errors
    ///
    /// Returns [`PackValidationError::ZeroTokenBudget`] when `max_tokens`
    /// is zero.
    pub const fn new(max_tokens: u32) -> Result<Self, PackValidationError> {
        if max_tokens == 0 {
            return Err(PackValidationError::ZeroTokenBudget);
        }
        Ok(Self { max_tokens })
    }

    #[must_use]
    pub const fn default_context() -> Self {
        Self {
            max_tokens: DEFAULT_CONTEXT_MAX_TOKENS,
        }
    }

    #[must_use]
    pub const fn max_tokens(self) -> u32 {
        self.max_tokens
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackProvenance {
    pub uri: ProvenanceUri,
    pub note: String,
}

impl PackProvenance {
    /// Create a provenance entry with a short human-readable note.
    ///
    /// # Errors
    ///
    /// Returns [`PackValidationError::EmptyProvenanceNote`] when `note`
    /// is empty after trimming.
    pub fn new(uri: ProvenanceUri, note: impl Into<String>) -> Result<Self, PackValidationError> {
        let note = trim_required(
            note.into(),
            PackValidationError::EmptyProvenanceNote { uri: uri.clone() },
        )?;
        Ok(Self { uri, note })
    }

    /// Render this source reference into the stable shape used by pack
    /// outputs.
    #[must_use]
    pub fn rendered(&self) -> RenderedPackProvenance {
        RenderedPackProvenance::from(self)
    }
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RenderedPackProvenance {
    pub uri: String,
    pub scheme: String,
    pub label: String,
    pub locator: Option<String>,
    pub note: String,
}

impl From<&PackProvenance> for RenderedPackProvenance {
    fn from(provenance: &PackProvenance) -> Self {
        let scheme = provenance.uri.scheme();
        let (label, locator) = rendered_provenance_label(&provenance.uri);
        Self {
            uri: redact_pack_provenance_text(&provenance.uri.to_string()),
            scheme: scheme.to_owned(),
            label: redact_pack_provenance_text(&label),
            locator: locator.map(|value| redact_pack_provenance_text(&value)),
            note: redact_pack_provenance_text(&provenance.note),
        }
    }
}

#[must_use]
pub fn pack_item_provenance_json(provenance: &[PackProvenance]) -> String {
    let entries = provenance
        .iter()
        .map(|source| {
            serde_json::json!({
                "uri": redact_pack_provenance_text(&source.uri.to_string()),
                "note": redact_pack_provenance_text(&source.note),
            })
        })
        .collect::<Vec<_>>();
    serde_json::json!({
        "schema": PACK_ITEM_PROVENANCE_SCHEMA_V1,
        "entries": entries,
    })
    .to_string()
}

pub(crate) fn redact_pack_provenance_text(value: &str) -> String {
    let path_redacted = redact_pack_absolute_path_like_segments(value);
    let secret_redacted = crate::policy::redact_secret_like_content(&path_redacted).content;
    redact_pack_absolute_path_like_segments(&secret_redacted)
}

fn redact_pack_absolute_path_like_segments(input: &str) -> String {
    const REDACTED_PATH: &str = "[REDACTED_PATH]";
    const PATH_PREFIXES: &[&str] = &[
        "/home/",
        "/Users/",
        "/data/",
        "/workspace/",
        "/Volumes/",
        "C:\\",
        "D:\\",
    ];

    let mut output = String::with_capacity(input.len());
    let mut cursor = 0usize;
    while cursor < input.len() {
        let remaining = &input[cursor..];
        if let Some(prefix) = PATH_PREFIXES
            .iter()
            .find(|prefix| remaining.starts_with(**prefix))
        {
            output.push_str(REDACTED_PATH);
            cursor += prefix.len();
            while cursor < input.len() {
                let next = input[cursor..].chars().next().unwrap_or('\0');
                if next.is_whitespace()
                    || matches!(
                        next,
                        '"' | '\''
                            | '`'
                            | '<'
                            | '>'
                            | ')'
                            | ']'
                            | '}'
                            | ','
                            | ';'
                            | '|'
                            | '?'
                            | '#'
                    )
                {
                    break;
                }
                cursor += next.len_utf8();
            }
            continue;
        }

        let next = remaining.chars().next().unwrap_or('\0');
        output.push(next);
        cursor += next.len_utf8();
    }

    output
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackItemProvenance {
    pub rank: u32,
    pub memory_id: MemoryId,
    pub source_index: u32,
    pub source: RenderedPackProvenance,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackProvenanceFooter {
    pub memory_count: usize,
    pub evidence_count: usize,
    pub source_count: usize,
    pub schemes: Vec<String>,
    pub entries: Vec<PackItemProvenance>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackCandidate {
    pub memory_id: MemoryId,
    pub section: PackSection,
    pub content: String,
    pub estimated_tokens: u32,
    pub relevance: UnitScore,
    pub utility: UnitScore,
    pub proximity_to_seed: Option<f32>,
    pub score_breakdown: Option<PackScoreBreakdown>,
    pub attempt_family_multiplicity: Option<PackAttemptFamilyMultiplicitySnapshot>,
    pub provenance: Vec<PackProvenance>,
    pub why: String,
    pub diversity_key: Option<String>,
    pub trust: PackTrustSignal,
    pub tombstoned_at: Option<String>,
    pub lifecycle: Option<PackItemLifecycle>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackCandidateInput {
    pub memory_id: MemoryId,
    pub section: PackSection,
    pub content: String,
    pub estimated_tokens: u32,
    pub relevance: UnitScore,
    pub utility: UnitScore,
    pub provenance: Vec<PackProvenance>,
    pub why: String,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PackScoreBreakdown {
    pub text_score: f32,
    pub ppr_score: f32,
    pub combined_score: f32,
}

/// Redaction-safe, immutable attempt-family state captured at pack assembly.
///
/// Family lookup IDs never enter this projection. Each membership carries only
/// a domain-separated public alias plus the exact posture and discount used by
/// ranking, so replay cannot be rewritten by siblings recorded later.
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackAttemptFamilyMultiplicitySnapshot {
    pub schema: &'static str,
    pub effective_discount_factor: f32,
    pub promotion_posture: String,
    pub promotion_reason: String,
    pub memberships: Vec<PackAttemptFamilyMembershipSnapshot>,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PackAttemptFamilyMembershipSnapshot {
    pub family_alias: String,
    pub member_disposition: String,
    pub member_discount_factor: f32,
    pub declared_size: Option<u32>,
    pub recorded_slots: u32,
    pub selected_count: u32,
    pub rejected_count: u32,
    pub unslotted_count: u32,
    pub duplicate_slot_count: u32,
    pub duplicate_member_count: u32,
    pub out_of_range_slot_count: u32,
    pub unrecorded_count: u32,
    pub promotion_posture: String,
    pub promotion_reason: String,
}

impl PackScoreBreakdown {
    #[must_use]
    pub fn ppr(text_score: f32, ppr_score: f32, combined_score: f32) -> Self {
        Self {
            text_score: finite_unit_float(text_score),
            ppr_score: finite_unit_float(ppr_score),
            combined_score: finite_unit_float(combined_score),
        }
    }
}

fn finite_unit_float(value: f32) -> f32 {
    if value.is_finite() {
        value.clamp(0.0, 1.0)
    } else {
        0.0
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackTrustSignal {
    pub class: TrustClass,
    pub subclass: Option<String>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackItemLifecycle {
    pub validity_status: String,
    pub validity_window_kind: String,
    pub valid_from: Option<String>,
    pub valid_to: Option<String>,
}

impl PackTrustSignal {
    #[must_use]
    pub fn new(class: TrustClass, subclass: Option<String>) -> Self {
        Self {
            class,
            subclass: subclass
                .map(|value| value.trim().to_string())
                .filter(|value| !value.is_empty()),
        }
    }

    #[must_use]
    pub const fn posture(&self) -> PackTrustPosture {
        PackTrustPosture::for_class(self.class)
    }
}

impl Default for PackTrustSignal {
    fn default() -> Self {
        Self::new(TrustClass::AgentAssertion, None)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackTrustPosture {
    Authoritative,
    Advisory,
    LegacyEvidence,
}

impl PackTrustPosture {
    #[must_use]
    pub const fn for_class(class: TrustClass) -> Self {
        match class {
            TrustClass::HumanExplicit
            | TrustClass::PeerHumanAttested
            | TrustClass::AgentValidated => Self::Authoritative,
            TrustClass::AgentAssertion | TrustClass::CassEvidence => Self::Advisory,
            TrustClass::LegacyImport => Self::LegacyEvidence,
        }
    }

    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Authoritative => "authoritative",
            Self::Advisory => "advisory",
            Self::LegacyEvidence => "legacy_evidence",
        }
    }
}

impl PackCandidate {
    /// Build a validated candidate for context packing.
    ///
    /// # Errors
    ///
    /// Returns a [`PackValidationError`] when the candidate lacks
    /// content, token estimates, provenance, or a selection explanation.
    pub fn new(input: PackCandidateInput) -> Result<Self, PackValidationError> {
        let PackCandidateInput {
            memory_id,
            section,
            content,
            estimated_tokens,
            relevance,
            utility,
            provenance,
            why,
        } = input;
        let content = trim_required(
            content,
            PackValidationError::EmptyCandidateContent { memory_id },
        )?;
        if estimated_tokens == 0 {
            return Err(PackValidationError::ZeroCandidateTokens { memory_id });
        }
        if provenance.is_empty() {
            return Err(PackValidationError::MissingProvenance { memory_id });
        }
        let why = trim_required(why, PackValidationError::MissingWhy { memory_id })?;
        Ok(Self {
            memory_id,
            section,
            content,
            estimated_tokens,
            relevance,
            utility,
            proximity_to_seed: None,
            score_breakdown: None,
            attempt_family_multiplicity: None,
            provenance,
            why,
            diversity_key: None,
            trust: PackTrustSignal::default(),
            tombstoned_at: None,
            lifecycle: None,
        })
    }

    #[must_use]
    pub fn with_diversity_key(mut self, diversity_key: impl Into<String>) -> Self {
        let value = diversity_key.into();
        if !value.trim().is_empty() {
            self.diversity_key = Some(value.trim().to_string());
        }
        self
    }

    #[must_use]
    pub const fn with_score_breakdown(mut self, score_breakdown: PackScoreBreakdown) -> Self {
        self.score_breakdown = Some(score_breakdown);
        self
    }

    #[must_use]
    pub fn with_proximity_to_seed(mut self, proximity_to_seed: f32) -> Self {
        if proximity_to_seed.is_finite() {
            self.proximity_to_seed = Some(proximity_to_seed.max(0.0));
        }
        self
    }

    #[must_use]
    pub fn with_trust_signal(mut self, trust: PackTrustSignal) -> Self {
        self.trust = trust;
        self
    }

    #[must_use]
    pub fn with_tombstoned_at(mut self, tombstoned_at: impl Into<String>) -> Self {
        let value = tombstoned_at.into();
        if !value.trim().is_empty() {
            self.tombstoned_at = Some(value.trim().to_string());
        }
        self
    }

    #[must_use]
    pub fn with_lifecycle(mut self, lifecycle: PackItemLifecycle) -> Self {
        self.lifecycle = Some(lifecycle);
        self
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackSelectionAudit {
    pub profile: ContextPackProfile,
    pub objective: PackSelectionObjective,
    pub algorithm_id: &'static str,
    pub algorithm_description: &'static str,
    pub candidate_count: usize,
    pub selected_count: usize,
    pub omitted_count: usize,
    pub budget_limit: u32,
    pub budget_used: u32,
    pub total_objective_value: f32,
    pub monotone: bool,
    pub submodular: bool,
    pub selected_items: Vec<PackSelectedItem>,
    pub steps: Vec<PackSelectionStep>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackSelectionObjective {
    MmrRedundancy,
    FacilityLocation,
}

impl PackSelectionObjective {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::MmrRedundancy => "mmr_redundancy",
            Self::FacilityLocation => "facility_location",
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackSelectionStep {
    pub rank: u32,
    pub memory_id: MemoryId,
    pub marginal_gain: f32,
    pub objective_value: f32,
    pub token_cost: u32,
    pub feasible: bool,
    pub covered_features: Vec<String>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackSelectedItem {
    pub rank: u32,
    pub memory_id: MemoryId,
    pub token_cost: u32,
    pub feasible: bool,
}

/// Map a memory trust class to a deterministic standing rank (higher = more
/// trusted) for the pack-time contradiction guard (bd-1n0np.7.5).
const fn trust_class_rank_milli(class: TrustClass) -> i64 {
    match class {
        TrustClass::HumanExplicit => 6_000,
        TrustClass::PeerHumanAttested => 5_000,
        TrustClass::AgentValidated => 4_000,
        TrustClass::AgentAssertion => 3_000,
        TrustClass::CassEvidence => 2_000,
        TrustClass::LegacyImport => 1_000,
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackDraft {
    pub query: String,
    pub budget: TokenBudget,
    pub used_tokens: u32,
    pub items: Vec<PackDraftItem>,
    /// Direct imported evidence selected without fabricating a memory identity.
    ///
    /// Memory-only ranking and graph algorithms intentionally operate on
    /// `items`; live-admitted evidence joins at the pack boundary under its
    /// canonical `EvidenceId` (bd-16imy).
    pub evidence_items: Vec<PackEvidenceItem>,
    pub omitted: Vec<PackOmission>,
    pub selection_audit: PackSelectionAudit,
    pub hash: Option<String>,
}

impl PackDraft {
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.items.is_empty() && self.evidence_items.is_empty()
    }

    /// bd-1n0np.7.5 — pack-time contradiction guard. Drops the lower-standing
    /// side of each unresolved hard-contradiction pair among the selected items,
    /// recording it as a [`PackOmissionReason::ContradictionSuppressed`] omission,
    /// so a pack never carries both sides of an unresolved contradiction.
    /// Standing is higher trust class, then better (lower) selection rank, then a
    /// deterministic id tie-break (via [`decide_contradiction_survivor`]). A no-op
    /// in `forced` mode (the caller surfaces both sides under a `## Contradictions`
    /// header instead). `unresolved_pairs` come from the 7.2 detector minus 7.4
    /// resolutions. Returns the number of items suppressed.
    pub fn apply_contradiction_guard(
        &mut self,
        unresolved_pairs: &[(String, String)],
        forced: bool,
    ) -> usize {
        if forced || unresolved_pairs.is_empty() || self.items.len() < 2 {
            return 0;
        }
        let standing: std::collections::BTreeMap<String, GuardedMemory> = self
            .items
            .iter()
            .map(|item| {
                let id = item.memory_id.to_string();
                (
                    id.clone(),
                    GuardedMemory {
                        memory_id: id,
                        trust_milli: trust_class_rank_milli(item.trust.class),
                        // Lower selection rank = stronger standing -> higher key.
                        freshness_epoch: -i64::from(item.rank),
                    },
                )
            })
            .collect();

        let mut suppressed: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
        for (a, b) in unresolved_pairs {
            if suppressed.contains(a) || suppressed.contains(b) {
                continue;
            }
            let (Some(ga), Some(gb)) = (standing.get(a), standing.get(b)) else {
                continue;
            };
            suppressed.insert(decide_contradiction_survivor(ga, gb).suppressed_memory_id);
        }
        if suppressed.is_empty() {
            return 0;
        }

        let count = suppressed.len();
        let mut kept = Vec::with_capacity(self.items.len().saturating_sub(count));
        for item in std::mem::take(&mut self.items) {
            if suppressed.contains(&item.memory_id.to_string()) {
                self.omitted.push(PackOmission {
                    memory_id: item.memory_id,
                    estimated_tokens: item.estimated_tokens,
                    relevance: item.relevance,
                    utility: item.utility,
                    attempt_family_multiplicity: item.attempt_family_multiplicity.clone(),
                    reason: PackOmissionReason::ContradictionSuppressed,
                    rejected_at: PackRejectionStage::Selection,
                    feasible: true,
                    could_fit_with_budget: None,
                });
            } else {
                kept.push(item);
            }
        }
        self.items = kept;
        self.used_tokens = self
            .items
            .iter()
            .map(|item| item.estimated_tokens)
            .sum::<u32>();
        self.selection_audit.selected_count = self.items.len();
        self.selection_audit.omitted_count = self.omitted.len();
        self.selection_audit.budget_used = self.used_tokens;
        self.selection_audit.selected_items = selected_items_from_draft_items(&self.items);
        refresh_selection_audit_objective_after_guard(&mut self.selection_audit, &self.items);
        self.hash = None;
        count
    }

    #[must_use]
    pub fn quality_metrics(&self) -> PackQualityMetrics {
        let item_count = self.items.len().saturating_add(self.evidence_items.len());
        let omitted_count = self.omitted.len();
        let provenance_source_count = self
            .items
            .iter()
            .map(|item| item.provenance.len())
            .sum::<usize>()
            .saturating_add(
                self.evidence_items
                    .iter()
                    .map(|item| item.provenance.len())
                    .sum::<usize>(),
            );

        let mut relevance_sum = 0.0_f32;
        let mut utility_sum = 0.0_f32;
        for item in &self.items {
            relevance_sum += item.relevance.into_inner();
            utility_sum += item.utility.into_inner();
        }
        for item in &self.evidence_items {
            relevance_sum += item.relevance.into_inner();
            utility_sum += item.utility.into_inner();
        }

        let mut token_budget_exceeded = 0_usize;
        let mut redundant_candidates = 0_usize;
        let mut below_relevance_floor = 0_usize;
        for omission in &self.omitted {
            match omission.reason {
                PackOmissionReason::TokenBudgetExceeded => {
                    token_budget_exceeded = token_budget_exceeded.saturating_add(1);
                }
                PackOmissionReason::RedundantCandidate => {
                    redundant_candidates = redundant_candidates.saturating_add(1);
                }
                PackOmissionReason::BelowRelevanceFloor => {
                    below_relevance_floor = below_relevance_floor.saturating_add(1);
                }
                PackOmissionReason::ExcludedByPolicy
                | PackOmissionReason::ExcludedByFilter
                | PackOmissionReason::ContradictionSuppressed => {}
            }
        }

        PackQualityMetrics {
            item_count,
            omitted_count,
            used_tokens: self.used_tokens,
            max_tokens: self.budget.max_tokens(),
            budget_utilization: token_ratio(self.used_tokens, self.budget.max_tokens()),
            average_relevance: average_metric(relevance_sum, item_count),
            average_utility: average_metric(utility_sum, item_count),
            provenance_source_count,
            provenance_sources_per_item: count_ratio(provenance_source_count, item_count),
            provenance_complete: self.items.iter().all(|item| !item.provenance.is_empty())
                && self
                    .evidence_items
                    .iter()
                    .all(|item| !item.provenance.is_empty()),
            coverage_fill_count: self.coverage_fill_count(),
            sections: PackSection::all()
                .into_iter()
                .map(|section| self.section_quality_metric(section))
                .collect(),
            omissions: PackOmissionMetrics {
                token_budget_exceeded,
                redundant_candidates,
                below_relevance_floor,
            },
        }
    }

    #[must_use]
    pub fn provenance_footer(&self) -> PackProvenanceFooter {
        let mut memory_ids = BTreeSet::new();
        let mut schemes = BTreeSet::new();
        let mut entries = Vec::new();

        for item in &self.items {
            memory_ids.insert(item.memory_id.to_string());
            for (index, provenance) in item.provenance.iter().enumerate() {
                let source = provenance.rendered();
                schemes.insert(source.scheme.clone());
                entries.push(PackItemProvenance {
                    rank: item.rank,
                    memory_id: item.memory_id,
                    source_index: source_index(index),
                    source,
                });
            }
        }
        let mut evidence_source_count = 0_usize;
        for item in &self.evidence_items {
            for provenance in &item.provenance {
                schemes.insert(provenance.rendered().scheme);
                evidence_source_count = evidence_source_count.saturating_add(1);
            }
        }

        PackProvenanceFooter {
            memory_count: memory_ids.len(),
            evidence_count: self.evidence_items.len(),
            source_count: entries.len().saturating_add(evidence_source_count),
            schemes: schemes.into_iter().collect(),
            entries,
        }
    }

    #[must_use]
    pub fn skipped_total(&self) -> usize {
        self.omitted.len()
    }

    #[must_use]
    pub fn skipped_for_output(&self) -> Vec<&PackOmission> {
        let mut skipped = self.omitted.iter().collect::<Vec<_>>();
        skipped.sort_by(|left, right| compare_omissions_for_output(left, right));
        skipped.truncate(MAX_PACK_SKIPPED_ITEMS);
        skipped
    }

    #[must_use]
    pub fn coverage_fill_count(&self) -> usize {
        self.items
            .iter()
            .filter(|item| item.selected_in == PackSelectionPhase::CoverageFill)
            .count()
    }

    #[must_use]
    pub fn trust_counts(&self) -> PackTrustCounts {
        let mut counts = PackTrustCounts::default();
        for item in &self.items {
            counts.add(item.trust.class);
        }
        for item in &self.evidence_items {
            counts.add(item.trust.class);
        }
        counts
    }

    fn section_quality_metric(&self, section: PackSection) -> PackSectionMetric {
        let mut item_count = 0_usize;
        let mut used_tokens = 0_u32;
        for item in &self.items {
            if item.section == section {
                item_count = item_count.saturating_add(1);
                used_tokens = used_tokens.saturating_add(item.estimated_tokens);
            }
        }
        for item in &self.evidence_items {
            if item.section == section {
                item_count = item_count.saturating_add(1);
                used_tokens = used_tokens.saturating_add(item.estimated_tokens);
            }
        }

        PackSectionMetric {
            section,
            item_count,
            used_tokens,
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct WhyNotSelectedInput {
    pub task: String,
    pub target: PackCandidate,
    pub candidates: Vec<PackCandidate>,
    pub budget: TokenBudget,
    pub profile: ContextPackProfile,
    pub exclusions: Vec<WhyNotSelectionExclusion>,
    pub degraded: Vec<WhyNotSelectionDegradation>,
    /// Assembly options the counterfactual pack is built with. Must match
    /// the options of the pack being explained, or the report describes a
    /// different selector (LOD default vs classic) than the one that ran.
    pub options: PackAssemblyOptions,
}

impl WhyNotSelectedInput {
    #[must_use]
    pub fn new(
        task: impl Into<String>,
        target: PackCandidate,
        budget: TokenBudget,
        profile: ContextPackProfile,
        candidates: Vec<PackCandidate>,
    ) -> Self {
        Self {
            task: task.into(),
            target,
            candidates,
            budget,
            profile,
            exclusions: Vec::new(),
            degraded: Vec::new(),
            options: PackAssemblyOptions::default(),
        }
    }

    #[must_use]
    pub fn with_options(mut self, options: PackAssemblyOptions) -> Self {
        self.options = options;
        self
    }

    #[must_use]
    pub fn with_exclusions(mut self, exclusions: Vec<WhyNotSelectionExclusion>) -> Self {
        self.exclusions = exclusions;
        self
    }

    #[must_use]
    pub fn with_degraded(mut self, degraded: Vec<WhyNotSelectionDegradation>) -> Self {
        self.degraded = degraded;
        self
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct WhyNotSelectionExclusion {
    pub kind: WhyNotSelectionExclusionKind,
    pub code: String,
    pub message: String,
    pub repair_action: Option<String>,
}

impl WhyNotSelectionExclusion {
    #[must_use]
    pub fn new(
        kind: WhyNotSelectionExclusionKind,
        code: impl Into<String>,
        message: impl Into<String>,
        repair_action: Option<String>,
    ) -> Self {
        Self {
            kind,
            code: code.into(),
            message: message.into(),
            repair_action,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WhyNotSelectionExclusionKind {
    Scope,
    Redaction,
    ValidityWindow,
    Policy,
    Filter,
}

impl WhyNotSelectionExclusionKind {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Scope => "scope",
            Self::Redaction => "redaction",
            Self::ValidityWindow => "validity_window",
            Self::Policy => "policy",
            Self::Filter => "filter",
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct WhyNotSelectionDegradation {
    pub code: String,
    pub severity: String,
    pub message: String,
    pub repair_action: Option<String>,
}

impl WhyNotSelectionDegradation {
    #[must_use]
    pub fn new(
        code: impl Into<String>,
        severity: impl Into<String>,
        message: impl Into<String>,
        repair_action: Option<String>,
    ) -> Self {
        Self {
            code: code.into(),
            severity: severity.into(),
            message: message.into(),
            repair_action,
        }
    }
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotSelectedReport {
    pub schema: &'static str,
    pub memory_id: String,
    pub task_hash: String,
    pub selected: bool,
    pub retrieval_stage_reached: String,
    pub primary_reason: String,
    pub reason_source: String,
    pub filters_applied: Vec<WhyNotSelectionFilterReport>,
    pub redaction_scope_exclusions: Vec<WhyNotSelectionExclusionReport>,
    pub degraded: Vec<WhyNotSelectionDegradationReport>,
    pub scores: WhyNotSelectionScoreReport,
    pub score_delta_to_last_included: Option<f32>,
    pub token_budget_frontier: WhyNotTokenBudgetFrontier,
    pub freshness_penalty: WhyNotFreshnessPenalty,
    pub trust_penalty: WhyNotTrustPenalty,
    pub counterfactual_hints: Vec<WhyNotCounterfactualHint>,
    pub provenance: Vec<RenderedPackProvenance>,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotSelectionFilterReport {
    pub stage: String,
    pub code: String,
    pub passed: bool,
    pub detail: String,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotSelectionExclusionReport {
    pub kind: String,
    pub code: String,
    pub stage: String,
    pub message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub repair_action: Option<String>,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotSelectionDegradationReport {
    pub code: String,
    pub severity: String,
    pub stage: String,
    pub message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub repair_action: Option<String>,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotSelectionScoreReport {
    pub target_relevance: f32,
    pub target_utility: f32,
    pub target_composite: f32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_included_memory_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_included_composite: Option<f32>,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotTokenBudgetFrontier {
    pub max_tokens: u32,
    pub used_tokens: u32,
    pub target_estimated_tokens: u32,
    pub required_additional_tokens: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub could_fit_with_budget: Option<u32>,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotFreshnessPenalty {
    pub value: f32,
    pub signals: Vec<String>,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotTrustPenalty {
    pub value: f32,
    pub trust_class: String,
    pub posture: String,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WhyNotCounterfactualHint {
    pub kind: String,
    pub action: String,
    pub rationale: String,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CoverageGapReport {
    pub schema: &'static str,
    pub task: String,
    pub task_hash: String,
    pub posture: String,
    pub pack_summary: CoverageGapPackSummary,
    pub missing_kinds: Vec<CoverageGapMissingKind>,
    pub nearest_insufficient: Vec<CoverageGapNearestInsufficient>,
    pub capture_templates: Vec<CoverageGapCaptureTemplate>,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CoverageGapPackSummary {
    pub selected_count: usize,
    pub omitted_count: usize,
    pub used_tokens: u32,
    pub max_tokens: u32,
    pub quality: String,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CoverageGapMissingKind {
    pub kind: String,
    pub expected_memory_kind: String,
    pub expected_level: String,
    pub section: String,
    pub reason: String,
    pub evidence_demand: String,
    pub confidence: u32,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CoverageGapNearestInsufficient {
    pub memory_id: String,
    pub section: String,
    pub selected: bool,
    pub reason: String,
    pub relevance: f32,
    pub utility: f32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content_preview: Option<String>,
    pub insufficient_for: Vec<String>,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CoverageGapCaptureTemplate {
    pub kind: String,
    pub level: String,
    pub memory_kind: String,
    pub content_template: String,
    pub command: String,
    pub source_hint: String,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct CoverageGapKindSpec {
    kind: &'static str,
    expected_memory_kind: &'static str,
    expected_level: &'static str,
    section: PackSection,
    trigger_terms: &'static [&'static str],
    marker_terms: &'static [&'static str],
    evidence_demand: &'static str,
    content_template: &'static str,
    source_hint: &'static str,
}

const RELEASE_RULE_TERMS: &[&str] = &["release", "ship", "deploy", "publish", "tag"];
const DECISION_TERMS: &[&str] = &["decision", "adr", "architecture", "design", "choose"];
const ANTI_PATTERN_TERMS: &[&str] = &[
    "anti-pattern",
    "antipattern",
    "avoid",
    "never",
    "regression",
    "failure",
    "blocked",
    "gotcha",
];
const PROCEDURAL_TERMS: &[&str] = &["rule", "checklist", "workflow", "command", "must"];

const COVERAGE_GAP_KIND_SPECS: &[CoverageGapKindSpec] = &[
    CoverageGapKindSpec {
        kind: "release_rule",
        expected_memory_kind: "rule",
        expected_level: "procedural",
        section: PackSection::ProceduralRules,
        trigger_terms: RELEASE_RULE_TERMS,
        marker_terms: RELEASE_RULE_TERMS,
        evidence_demand: "A release/deploy task needs a concrete release rule or checklist with gates, rollback, and verification commands.",
        content_template: "Before releasing <target>, run <verification commands>, confirm <rollback condition>, and record <release evidence>.",
        source_hint: "file://AGENTS.md#L<line> or file://docs/release.md#L<line>",
    },
    CoverageGapKindSpec {
        kind: "decision",
        expected_memory_kind: "decision",
        expected_level: "semantic",
        section: PackSection::Decisions,
        trigger_terms: DECISION_TERMS,
        marker_terms: &["decision", "decided", "adr", "choose", "chosen", "because"],
        evidence_demand: "The task mentions design or architecture pressure but the pack lacks a decision record explaining the chosen direction.",
        content_template: "Decision: for <task/context>, choose <approach> because <evidence>; rejected alternatives: <alternatives>.",
        source_hint: "file://docs/adr/<id>.md#L<line> or file://README.md#L<line>",
    },
    CoverageGapKindSpec {
        kind: "anti_pattern",
        expected_memory_kind: "anti-pattern",
        expected_level: "procedural",
        section: PackSection::Failures,
        trigger_terms: ANTI_PATTERN_TERMS,
        marker_terms: ANTI_PATTERN_TERMS,
        evidence_demand: "A risky or failure-prone task needs at least one remembered anti-pattern/failure mode so the pack can steer away from repeated mistakes.",
        content_template: "Anti-pattern: when working on <surface>, do not <risky action>; prior failure/evidence: <what happened>; safer path: <replacement action>.",
        source_hint: "file://docs/incidents/<date>.md#L<line> or cass-session://<session>#L<line>",
    },
    CoverageGapKindSpec {
        kind: "procedural_rule",
        expected_memory_kind: "rule",
        expected_level: "procedural",
        section: PackSection::ProceduralRules,
        trigger_terms: PROCEDURAL_TERMS,
        marker_terms: PROCEDURAL_TERMS,
        evidence_demand: "The task needs a concrete procedural guardrail, but the pack lacks a rule/checklist matching the requested work.",
        content_template: "Rule: before <task>, run <command/check>, inspect <artifact>, and stop if <failure condition>.",
        source_hint: "file://AGENTS.md#L<line> or file://docs/testing-strategy.md#L<line>",
    },
];

/// Explain why a candidate memory was not selected for a context-pack task.
///
/// The report is read-only and deliberately omits the target memory content.
/// Callers provide the exact candidate universe and any pre-selection
/// exclusion/degradation facts they observed while retrieving candidates.
///
/// # Errors
///
/// Returns pack validation errors for an empty task or invalid draft assembly.
pub fn explain_why_not_selected(
    input: WhyNotSelectedInput,
) -> Result<WhyNotSelectedReport, PackValidationError> {
    let task = trim_required(input.task, PackValidationError::EmptyQuery)?;
    let target = input.target;
    let target_memory_id = target.memory_id;
    let target_present = input
        .candidates
        .iter()
        .any(|candidate| candidate.memory_id == target_memory_id);
    let exclusions = input.exclusions;
    let degraded = input.degraded;

    let draft = if target_present && exclusions.is_empty() {
        Some(assemble_draft_with_profile_and_options(
            input.profile,
            task.clone(),
            input.budget,
            input.candidates,
            input.options,
        )?)
    } else {
        None
    };

    let selected_item = draft.as_ref().and_then(|draft| {
        draft
            .items
            .iter()
            .find(|item| item.memory_id == target_memory_id)
    });
    let omission = draft.as_ref().and_then(|draft| {
        draft
            .omitted
            .iter()
            .find(|omission| omission.memory_id == target_memory_id)
    });
    let last_included = draft
        .as_ref()
        .and_then(|draft| draft.items.iter().max_by_key(|item| item.rank));
    let selected = selected_item.is_some();
    let primary_reason =
        why_not_primary_reason(target_present, selected, omission, &exclusions, &degraded);
    let reason_source = why_not_reason_source(&primary_reason);
    let stage = why_not_stage(target_present, selected, omission, &exclusions, &degraded);
    let token_frontier = why_not_token_frontier(input.budget, &target, draft.as_ref(), omission);
    let scores = why_not_scores(&target, last_included);
    let score_delta = scores
        .last_included_composite
        .map(|last| round_metric(scores.target_composite - last));
    let freshness_penalty = why_not_freshness_penalty(&target);
    let trust_penalty = why_not_trust_penalty(&target);
    let filters = why_not_filters(target_present, selected, omission, &exclusions, &degraded);
    let exclusion_reports = exclusions
        .into_iter()
        .map(why_not_exclusion_report)
        .collect::<Vec<_>>();
    let degradation_reports = degraded
        .into_iter()
        .map(why_not_degradation_report)
        .collect::<Vec<_>>();
    let hints = why_not_counterfactual_hints(
        &primary_reason,
        &token_frontier,
        score_delta,
        &freshness_penalty,
        &trust_penalty,
        &exclusion_reports,
        &degradation_reports,
    );

    Ok(WhyNotSelectedReport {
        schema: WHY_NOT_SELECTED_SCHEMA_V1,
        memory_id: target_memory_id.to_string(),
        task_hash: blake3::hash(task.as_bytes()).to_hex().to_string(),
        selected,
        retrieval_stage_reached: stage,
        primary_reason,
        reason_source,
        filters_applied: filters,
        redaction_scope_exclusions: exclusion_reports,
        degraded: degradation_reports,
        scores,
        score_delta_to_last_included: score_delta,
        token_budget_frontier: token_frontier,
        freshness_penalty,
        trust_penalty,
        counterfactual_hints: hints,
        provenance: target
            .provenance
            .iter()
            .map(PackProvenance::rendered)
            .collect(),
    })
}

#[must_use]
pub fn explain_coverage_gap(task: impl Into<String>, pack: &PackDraft) -> CoverageGapReport {
    let task = task.into();
    let task_lower = task.to_ascii_lowercase();
    let expected_specs = expected_gap_specs_for_task(&task_lower);
    let missing_specs = expected_specs
        .into_iter()
        .filter(|spec| !pack_satisfies_gap_spec(pack, spec))
        .collect::<Vec<_>>();
    let missing_kinds = missing_specs
        .iter()
        .map(|spec| CoverageGapMissingKind {
            kind: spec.kind.to_string(),
            expected_memory_kind: spec.expected_memory_kind.to_string(),
            expected_level: spec.expected_level.to_string(),
            section: spec.section.as_str().to_string(),
            reason: format!(
                "No selected memory in {} satisfies `{}` demand for this task.",
                spec.section.as_str(),
                spec.kind
            ),
            evidence_demand: spec.evidence_demand.to_string(),
            confidence: coverage_gap_confidence(&task_lower, spec),
        })
        .collect::<Vec<_>>();
    let nearest_insufficient = coverage_gap_nearest_insufficient(pack, &missing_specs);
    let capture_templates = missing_specs
        .iter()
        .map(|spec| coverage_gap_capture_template(&task, spec))
        .collect::<Vec<_>>();
    CoverageGapReport {
        schema: COVERAGE_GAP_SCHEMA_V1,
        task: task.clone(),
        task_hash: blake3::hash(task.as_bytes()).to_hex().to_string(),
        posture: coverage_gap_posture(pack, missing_kinds.len()),
        pack_summary: CoverageGapPackSummary {
            selected_count: pack.items.len(),
            omitted_count: pack.omitted.len(),
            used_tokens: pack.used_tokens,
            max_tokens: pack.budget.max_tokens(),
            quality: coverage_gap_quality(pack, missing_kinds.len()),
        },
        missing_kinds,
        nearest_insufficient,
        capture_templates,
    }
}

fn expected_gap_specs_for_task(task_lower: &str) -> Vec<&'static CoverageGapKindSpec> {
    let mut specs = Vec::new();
    for spec in COVERAGE_GAP_KIND_SPECS {
        if spec
            .trigger_terms
            .iter()
            .any(|term| task_lower.contains(term))
            || matches!(spec.kind, "decision" | "anti_pattern")
        {
            specs.push(spec);
        }
    }
    specs.sort_by(|left, right| left.kind.cmp(right.kind));
    specs.dedup_by(|left, right| left.kind == right.kind);
    specs
}

fn pack_satisfies_gap_spec(pack: &PackDraft, spec: &CoverageGapKindSpec) -> bool {
    pack.items
        .iter()
        .any(|item| item.section == spec.section && content_satisfies_gap_spec(&item.content, spec))
}

fn content_satisfies_gap_spec(content: &str, spec: &CoverageGapKindSpec) -> bool {
    let lower = content.to_ascii_lowercase();
    spec.marker_terms.iter().any(|term| lower.contains(term))
}

fn coverage_gap_confidence(task_lower: &str, spec: &CoverageGapKindSpec) -> u32 {
    if spec
        .trigger_terms
        .iter()
        .any(|term| task_lower.contains(term))
    {
        90
    } else {
        70
    }
}

fn coverage_gap_quality(pack: &PackDraft, missing_count: usize) -> String {
    if pack.items.is_empty() {
        "empty".to_string()
    } else if missing_count >= 2 || pack.items.len() <= 1 {
        "thin".to_string()
    } else if missing_count == 1 {
        "partial".to_string()
    } else {
        "covered".to_string()
    }
}

fn coverage_gap_posture(pack: &PackDraft, missing_count: usize) -> String {
    if pack.items.is_empty() || missing_count >= 2 {
        "capture_required".to_string()
    } else if missing_count == 1 {
        "capture_recommended".to_string()
    } else {
        "covered".to_string()
    }
}

fn coverage_gap_nearest_insufficient(
    pack: &PackDraft,
    missing_specs: &[&CoverageGapKindSpec],
) -> Vec<CoverageGapNearestInsufficient> {
    if missing_specs.is_empty() {
        return Vec::new();
    }
    let insufficient_for = missing_specs
        .iter()
        .map(|spec| spec.kind.to_string())
        .collect::<Vec<_>>();
    let mut rows = pack
        .items
        .iter()
        .map(|item| CoverageGapNearestInsufficient {
            memory_id: item.memory_id.to_string(),
            section: item.section.as_str().to_string(),
            selected: true,
            reason: "selected_but_gap_remains".to_string(),
            relevance: round_metric(item.relevance.into_inner()),
            utility: round_metric(item.utility.into_inner()),
            content_preview: Some(coverage_gap_content_preview(&item.content)),
            insufficient_for: insufficient_for.clone(),
        })
        .chain(
            pack.omitted
                .iter()
                .map(|omission| CoverageGapNearestInsufficient {
                    memory_id: omission.memory_id.to_string(),
                    section: "omitted_candidate".to_string(),
                    selected: false,
                    reason: omission.reason.as_str().to_string(),
                    relevance: round_metric(omission.relevance.into_inner()),
                    utility: round_metric(omission.utility.into_inner()),
                    content_preview: None,
                    insufficient_for: insufficient_for.clone(),
                }),
        )
        .collect::<Vec<_>>();
    rows.sort_by(|left, right| {
        compare_f32_desc(left.relevance, right.relevance)
            .then_with(|| compare_f32_desc(left.utility, right.utility))
            .then_with(|| left.memory_id.cmp(&right.memory_id))
    });
    rows.truncate(3);
    rows
}

fn coverage_gap_capture_template(
    task: &str,
    spec: &CoverageGapKindSpec,
) -> CoverageGapCaptureTemplate {
    let content = spec.content_template.replace("<task/context>", task);
    CoverageGapCaptureTemplate {
        kind: spec.kind.to_string(),
        level: spec.expected_level.to_string(),
        memory_kind: spec.expected_memory_kind.to_string(),
        content_template: content.clone(),
        command: format!(
            "ee remember {} --level {} --kind {} --source {} --json",
            shell_quote(&content),
            spec.expected_level,
            spec.expected_memory_kind,
            shell_quote(spec.source_hint)
        ),
        source_hint: spec.source_hint.to_string(),
    }
}

fn coverage_gap_content_preview(content: &str) -> String {
    let collapsed = content.split_whitespace().collect::<Vec<_>>().join(" ");
    const MAX_CHARS: usize = 120;
    if collapsed.chars().count() <= MAX_CHARS {
        collapsed
    } else {
        collapsed.chars().take(MAX_CHARS).collect()
    }
}

fn compare_f32_desc(left: f32, right: f32) -> Ordering {
    right.partial_cmp(&left).unwrap_or(Ordering::Equal)
}

fn why_not_reason_source(primary_reason: &str) -> String {
    match primary_reason {
        "not_retrieved" | "not_retrieved_due_to_degraded_index" => "reconstructed",
        _ => "authoritative",
    }
    .to_string()
}

fn why_not_primary_reason(
    target_present: bool,
    selected: bool,
    omission: Option<&PackOmission>,
    exclusions: &[WhyNotSelectionExclusion],
    degraded: &[WhyNotSelectionDegradation],
) -> String {
    if selected {
        return "selected".to_string();
    }
    if let Some(exclusion) = exclusions.first() {
        return match exclusion.kind {
            WhyNotSelectionExclusionKind::Scope => "excluded_by_scope",
            WhyNotSelectionExclusionKind::Redaction => "excluded_by_redaction",
            WhyNotSelectionExclusionKind::ValidityWindow => "excluded_by_validity_window",
            WhyNotSelectionExclusionKind::Policy => "excluded_by_policy",
            WhyNotSelectionExclusionKind::Filter => "excluded_by_filter",
        }
        .to_string();
    }
    if !target_present {
        if degraded.is_empty() {
            return "not_retrieved".to_string();
        }
        return "not_retrieved_due_to_degraded_index".to_string();
    }
    if let Some(omission) = omission {
        return match omission.reason {
            PackOmissionReason::TokenBudgetExceeded => "omitted_by_token_budget",
            PackOmissionReason::RedundantCandidate => "omitted_by_redundancy",
            PackOmissionReason::BelowRelevanceFloor => "omitted_by_score_floor",
            PackOmissionReason::ExcludedByPolicy => "excluded_by_policy",
            PackOmissionReason::ExcludedByFilter => "excluded_by_filter",
            PackOmissionReason::ContradictionSuppressed => "contradiction_suppressed",
        }
        .to_string();
    }
    "not_ranked".to_string()
}

fn why_not_stage(
    target_present: bool,
    selected: bool,
    omission: Option<&PackOmission>,
    exclusions: &[WhyNotSelectionExclusion],
    degraded: &[WhyNotSelectionDegradation],
) -> String {
    if selected {
        return "selected".to_string();
    }
    if let Some(exclusion) = exclusions.first() {
        return match exclusion.kind {
            WhyNotSelectionExclusionKind::Scope
            | WhyNotSelectionExclusionKind::Redaction
            | WhyNotSelectionExclusionKind::ValidityWindow
            | WhyNotSelectionExclusionKind::Policy
            | WhyNotSelectionExclusionKind::Filter => "candidate_filter",
        }
        .to_string();
    }
    if !target_present {
        if degraded.is_empty() {
            return "retrieval".to_string();
        }
        return "degraded_index".to_string();
    }
    omission
        .map(|omission| omission.rejected_at.as_str().to_string())
        .unwrap_or_else(|| "selection".to_string())
}

fn why_not_token_frontier(
    budget: TokenBudget,
    target: &PackCandidate,
    draft: Option<&PackDraft>,
    omission: Option<&PackOmission>,
) -> WhyNotTokenBudgetFrontier {
    let max_tokens = budget.max_tokens();
    let used_tokens = draft.map_or(0, |draft| draft.used_tokens);
    let could_fit_with_budget = omission.and_then(|omission| omission.could_fit_with_budget);
    let required_additional_tokens = could_fit_with_budget
        .map(|required| required.saturating_sub(max_tokens))
        .unwrap_or_else(|| {
            used_tokens
                .saturating_add(target.estimated_tokens)
                .saturating_sub(max_tokens)
        });
    WhyNotTokenBudgetFrontier {
        max_tokens,
        used_tokens,
        target_estimated_tokens: target.estimated_tokens,
        required_additional_tokens,
        could_fit_with_budget,
    }
}

fn why_not_scores(
    target: &PackCandidate,
    last_included: Option<&PackDraftItem>,
) -> WhyNotSelectionScoreReport {
    let target_composite = why_not_candidate_score(target.relevance, target.utility);
    let last_included_composite =
        last_included.map(|item| why_not_candidate_score(item.relevance, item.utility));
    WhyNotSelectionScoreReport {
        target_relevance: round_metric(target.relevance.into_inner()),
        target_utility: round_metric(target.utility.into_inner()),
        target_composite,
        last_included_memory_id: last_included.map(|item| item.memory_id.to_string()),
        last_included_composite,
    }
}

fn why_not_candidate_score(relevance: UnitScore, utility: UnitScore) -> f32 {
    round_metric(
        (DEFAULT_MMR_RELEVANCE_WEIGHT * relevance.into_inner())
            + ((1.0 - DEFAULT_MMR_RELEVANCE_WEIGHT) * utility.into_inner()),
    )
}

fn why_not_freshness_penalty(target: &PackCandidate) -> WhyNotFreshnessPenalty {
    let mut value = 0.0_f32;
    let mut signals = Vec::new();
    if target.tombstoned_at.is_some() {
        value = value.max(1.0);
        signals.push("tombstoned".to_string());
    }
    if let Some(lifecycle) = &target.lifecycle {
        // `validity_status` is one of `current`, `unknown`, `future`, `expired`,
        // or `malformed` (see `validity_status_for_memory`). Only `future`,
        // `expired`, and `malformed` are freshness defects; `current` (in-window)
        // and `unknown` (unbounded window) are healthy and must not be penalized.
        if lifecycle.validity_status != "current" && lifecycle.validity_status != "unknown" {
            value = value.max(0.5);
            signals.push(format!("validity_status:{}", lifecycle.validity_status));
        }
        if lifecycle.validity_window_kind != "unbounded" {
            signals.push(format!(
                "validity_window_kind:{}",
                lifecycle.validity_window_kind
            ));
        }
    }
    WhyNotFreshnessPenalty {
        value: round_metric(value),
        signals,
    }
}

fn why_not_trust_penalty(target: &PackCandidate) -> WhyNotTrustPenalty {
    let value = match target.trust.posture() {
        PackTrustPosture::Authoritative => 0.0,
        PackTrustPosture::Advisory => 0.1,
        PackTrustPosture::LegacyEvidence => 0.25,
    };
    WhyNotTrustPenalty {
        value: round_metric(value),
        trust_class: target.trust.class.as_str().to_string(),
        posture: target.trust.posture().as_str().to_string(),
    }
}

fn why_not_filters(
    target_present: bool,
    selected: bool,
    omission: Option<&PackOmission>,
    exclusions: &[WhyNotSelectionExclusion],
    degraded: &[WhyNotSelectionDegradation],
) -> Vec<WhyNotSelectionFilterReport> {
    let mut filters = vec![WhyNotSelectionFilterReport {
        stage: "retrieval".to_string(),
        code: "retrieval_candidate_present".to_string(),
        passed: target_present,
        detail: if target_present {
            "target memory reached the pack candidate universe"
        } else {
            "target memory was absent from the pack candidate universe"
        }
        .to_string(),
    }];
    for exclusion in exclusions {
        filters.push(WhyNotSelectionFilterReport {
            stage: "candidate_filter".to_string(),
            code: exclusion.code.clone(),
            passed: false,
            detail: exclusion.message.clone(),
        });
    }
    for degradation in degraded {
        filters.push(WhyNotSelectionFilterReport {
            stage: "retrieval".to_string(),
            code: degradation.code.clone(),
            passed: false,
            detail: degradation.message.clone(),
        });
    }
    if let Some(omission) = omission {
        filters.push(WhyNotSelectionFilterReport {
            stage: omission.rejected_at.as_str().to_string(),
            code: omission.reason.as_str().to_string(),
            passed: false,
            detail: format!("target memory was omitted at {}", omission.rejected_at),
        });
    } else if target_present && selected {
        filters.push(WhyNotSelectionFilterReport {
            stage: "selection".to_string(),
            code: "selected".to_string(),
            passed: true,
            detail: "target memory was selected".to_string(),
        });
    }
    filters
}

fn why_not_exclusion_report(exclusion: WhyNotSelectionExclusion) -> WhyNotSelectionExclusionReport {
    WhyNotSelectionExclusionReport {
        kind: exclusion.kind.as_str().to_string(),
        code: exclusion.code,
        stage: "candidate_filter".to_string(),
        message: exclusion.message,
        repair_action: exclusion.repair_action,
    }
}

fn why_not_degradation_report(
    degradation: WhyNotSelectionDegradation,
) -> WhyNotSelectionDegradationReport {
    WhyNotSelectionDegradationReport {
        code: degradation.code,
        severity: degradation.severity,
        stage: "retrieval".to_string(),
        message: degradation.message,
        repair_action: degradation.repair_action,
    }
}

fn why_not_counterfactual_hints(
    primary_reason: &str,
    token_frontier: &WhyNotTokenBudgetFrontier,
    score_delta: Option<f32>,
    freshness_penalty: &WhyNotFreshnessPenalty,
    trust_penalty: &WhyNotTrustPenalty,
    exclusions: &[WhyNotSelectionExclusionReport],
    degraded: &[WhyNotSelectionDegradationReport],
) -> Vec<WhyNotCounterfactualHint> {
    let mut hints = Vec::new();
    match primary_reason {
        "omitted_by_token_budget" => hints.push(WhyNotCounterfactualHint {
            kind: "raise_token_budget".to_string(),
            action: format!(
                "increase maxTokens by at least {}",
                token_frontier.required_additional_tokens.max(1)
            ),
            rationale: "the target candidate reached selection but did not fit the token frontier"
                .to_string(),
        }),
        "omitted_by_redundancy" => hints.push(WhyNotCounterfactualHint {
            kind: "inspect_overlap".to_string(),
            action:
                "compare selected memories with the same diversity bucket or normalized content"
                    .to_string(),
            rationale: "the target candidate overlapped already selected evidence".to_string(),
        }),
        "omitted_by_score_floor" => hints.push(WhyNotCounterfactualHint {
            kind: "improve_retrieval_score".to_string(),
            action: "add stronger task terms or validate the memory to improve relevance"
                .to_string(),
            rationale: "the target candidate was below the deterministic relevance floor"
                .to_string(),
        }),
        "not_retrieved" | "not_retrieved_due_to_degraded_index" => {
            hints.push(WhyNotCounterfactualHint {
                kind: "repair_retrieval".to_string(),
                action: "inspect search filters, scope, and index freshness for the target memory"
                    .to_string(),
                rationale: "the target memory did not reach pack selection".to_string(),
            });
        }
        _ => {}
    }
    if score_delta.is_some_and(|delta| delta < 0.0) {
        hints.push(WhyNotCounterfactualHint {
            kind: "raise_rank_score".to_string(),
            action: "increase relevance, utility, or trust evidence before expecting inclusion"
                .to_string(),
            rationale: "the target score trailed the last included memory".to_string(),
        });
    }
    if freshness_penalty.value > 0.0 {
        hints.push(WhyNotCounterfactualHint {
            kind: "repair_freshness".to_string(),
            action: "revise or revalidate the memory validity window".to_string(),
            rationale: "freshness signals reduced confidence in the target memory".to_string(),
        });
    }
    if trust_penalty.value > 0.0 {
        hints.push(WhyNotCounterfactualHint {
            kind: "raise_trust".to_string(),
            action: "attach validated outcome evidence to raise the memory trust posture"
                .to_string(),
            rationale: "non-authoritative trust posture is tracked as a counterfactual penalty"
                .to_string(),
        });
    }
    for exclusion in exclusions {
        hints.push(WhyNotCounterfactualHint {
            kind: format!("repair_{}", exclusion.kind),
            action: exclusion
                .repair_action
                .clone()
                .unwrap_or_else(|| format!("repair {}", exclusion.code)),
            rationale: exclusion.message.clone(),
        });
    }
    for degradation in degraded {
        hints.push(WhyNotCounterfactualHint {
            kind: "repair_degraded_index".to_string(),
            action: degradation
                .repair_action
                .clone()
                .unwrap_or_else(|| format!("repair {}", degradation.code)),
            rationale: degradation.message.clone(),
        });
    }
    hints.sort_by(|left, right| {
        left.kind
            .cmp(&right.kind)
            .then_with(|| left.action.cmp(&right.action))
    });
    hints.dedup_by(|left, right| left.kind == right.kind && left.action == right.action);
    hints
}

fn round_metric(value: f32) -> f32 {
    if value == 0.0 {
        0.0
    } else {
        (value * 1_000_000.0).round() / 1_000_000.0
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PackTrustCounts {
    pub human_explicit: usize,
    pub peer_human_attested: usize,
    pub agent_validated: usize,
    pub agent_assertion: usize,
    pub cass_evidence: usize,
    pub legacy_import: usize,
}

impl PackTrustCounts {
    fn add(&mut self, class: TrustClass) {
        match class {
            TrustClass::HumanExplicit => {
                self.human_explicit = self.human_explicit.saturating_add(1);
            }
            TrustClass::PeerHumanAttested => {
                self.peer_human_attested = self.peer_human_attested.saturating_add(1);
            }
            TrustClass::AgentValidated => {
                self.agent_validated = self.agent_validated.saturating_add(1);
            }
            TrustClass::AgentAssertion => {
                self.agent_assertion = self.agent_assertion.saturating_add(1);
            }
            TrustClass::CassEvidence => {
                self.cass_evidence = self.cass_evidence.saturating_add(1);
            }
            TrustClass::LegacyImport => {
                self.legacy_import = self.legacy_import.saturating_add(1);
            }
        }
    }

    #[must_use]
    pub const fn authoritative(&self) -> usize {
        self.human_explicit
            .saturating_add(self.peer_human_attested)
            .saturating_add(self.agent_validated)
    }

    #[must_use]
    pub const fn advisory(&self) -> usize {
        self.agent_assertion.saturating_add(self.cass_evidence)
    }

    #[must_use]
    pub const fn legacy(&self) -> usize {
        self.legacy_import
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackAdvisoryBanner {
    pub status: PackAdvisoryStatus,
    pub summary: String,
    pub authoritative_count: usize,
    pub advisory_count: usize,
    pub legacy_count: usize,
    pub degradation_count: usize,
    pub notes: Vec<PackAdvisoryNote>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackAdvisoryStatus {
    Clear,
    Advisory,
    Degraded,
}

impl PackAdvisoryStatus {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Clear => "clear",
            Self::Advisory => "advisory",
            Self::Degraded => "degraded",
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackAdvisoryNote {
    pub code: &'static str,
    pub severity: ContextResponseSeverity,
    pub message: String,
    pub memory_ids: Vec<String>,
    pub action: &'static str,
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackQualityMetrics {
    pub item_count: usize,
    pub omitted_count: usize,
    pub used_tokens: u32,
    pub max_tokens: u32,
    pub budget_utilization: f32,
    pub average_relevance: f32,
    pub average_utility: f32,
    pub provenance_source_count: usize,
    pub provenance_sources_per_item: f32,
    pub provenance_complete: bool,
    pub coverage_fill_count: usize,
    pub sections: Vec<PackSectionMetric>,
    pub omissions: PackOmissionMetrics,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackSectionMetric {
    pub section: PackSection,
    pub item_count: usize,
    pub used_tokens: u32,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackOmissionMetrics {
    pub token_budget_exceeded: usize,
    pub redundant_candidates: usize,
    pub below_relevance_floor: usize,
}

pub const PACK_ASSEMBLY_SLO_SCHEMA_V1: &str = "ee.pack.slo.v1";
pub const PACK_ASSEMBLY_SLOW_CODE: &str = "pack_assembly_slow";
pub const PACK_ASSEMBLY_BUDGET_EXCEEDED_CODE: &str = "pack_assembly_budget_exceeded";
pub const PACK_CONCURRENT_LIMIT_REACHED_CODE: &str = "pack_concurrent_limit_reached";
pub const PACK_BUDGET_TOO_SMALL_CODE: &str = "pack_budget_too_small";
pub const CONSENSUS_SCHEMA_V1: &str = "ee.consensus.v1";
pub const CONFLICT_SCHEMA_V1: &str = "ee.conflict.v1";

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum PackResourceProfile {
    Lean,
    #[default]
    Standard,
    SwarmHeavy,
}

impl PackResourceProfile {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Lean => "lean",
            Self::Standard => "standard",
            Self::SwarmHeavy => "swarm_heavy",
        }
    }

    #[must_use]
    pub const fn budget_class(self) -> PackSloBudgetClass {
        match self {
            Self::Lean => PackSloBudgetClass {
                candidates_scanned_max: 80,
                graph_traversal_max_edges: 1_024,
                elapsed_ms_target: 50,
                elapsed_ms_warning: 100,
                elapsed_ms_failure: 200,
                concurrent_pack_max: 1,
            },
            Self::Standard => PackSloBudgetClass {
                candidates_scanned_max: 240,
                graph_traversal_max_edges: 8_192,
                elapsed_ms_target: 200,
                elapsed_ms_warning: 500,
                elapsed_ms_failure: 2_000,
                concurrent_pack_max: 4,
            },
            Self::SwarmHeavy => PackSloBudgetClass {
                candidates_scanned_max: 1_600,
                graph_traversal_max_edges: 65_536,
                elapsed_ms_target: 1_000,
                elapsed_ms_warning: 2_000,
                elapsed_ms_failure: 10_000,
                concurrent_pack_max: 16,
            },
        }
    }
}

impl fmt::Display for PackResourceProfile {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

impl std::str::FromStr for PackResourceProfile {
    type Err = ParsePackResourceProfileError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        let trimmed = input.trim();
        let mut normalized = String::with_capacity(trimmed.len());
        let mut previous_was_lowercase = false;
        let mut previous_was_separator = false;

        for character in trimmed.chars() {
            match character {
                '-' | '_' => {
                    if !normalized.is_empty() && !previous_was_separator {
                        normalized.push('_');
                    }
                    previous_was_lowercase = false;
                    previous_was_separator = true;
                }
                character if character.is_ascii_uppercase() => {
                    if previous_was_lowercase && !previous_was_separator {
                        normalized.push('_');
                    }
                    normalized.push(character.to_ascii_lowercase());
                    previous_was_lowercase = false;
                    previous_was_separator = false;
                }
                character => {
                    normalized.push(character.to_ascii_lowercase());
                    previous_was_lowercase = character.is_ascii_lowercase();
                    previous_was_separator = false;
                }
            }
        }

        match normalized.as_str() {
            "lean" => Ok(Self::Lean),
            "standard" => Ok(Self::Standard),
            "swarm_heavy" => Ok(Self::SwarmHeavy),
            _ => Err(ParsePackResourceProfileError {
                value: input.to_string(),
            }),
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ParsePackResourceProfileError {
    value: String,
}

impl fmt::Display for ParsePackResourceProfileError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "invalid resource profile `{}`; expected lean, standard, or swarm_heavy/swarm-heavy",
            self.value
        )
    }
}

impl std::error::Error for ParsePackResourceProfileError {}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PackSloBudgetClass {
    pub candidates_scanned_max: usize,
    pub graph_traversal_max_edges: usize,
    pub elapsed_ms_target: u64,
    pub elapsed_ms_warning: u64,
    pub elapsed_ms_failure: u64,
    pub concurrent_pack_max: usize,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackAdmissionOutcome {
    Admitted,
    Backoff,
}

impl PackAdmissionOutcome {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Admitted => "admitted",
            Self::Backoff => "backoff",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PackAdmissionPosture {
    pub outcome: PackAdmissionOutcome,
    pub queue_depth: usize,
    pub concurrent_pack_max: usize,
    pub retry_after_ms: Option<u64>,
    pub waited_ms: u64,
}

impl PackAdmissionPosture {
    #[must_use]
    pub const fn admitted(queue_depth: usize, concurrent_pack_max: usize) -> Self {
        Self {
            outcome: PackAdmissionOutcome::Admitted,
            queue_depth,
            concurrent_pack_max,
            retry_after_ms: None,
            waited_ms: 0,
        }
    }

    #[must_use]
    pub const fn backoff(
        queue_depth: usize,
        concurrent_pack_max: usize,
        retry_after_ms: u64,
    ) -> Self {
        Self {
            outcome: PackAdmissionOutcome::Backoff,
            queue_depth,
            concurrent_pack_max,
            retry_after_ms: Some(retry_after_ms),
            waited_ms: 0,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PackAssemblySloActuals {
    pub candidate_count: usize,
    pub scanned_count: usize,
    pub index_generation: Option<u64>,
    pub graph_generation: Option<u64>,
    pub graph_edges_traversed: usize,
    pub elapsed_ms: u64,
    pub memory_bytes_peak: u64,
}

impl PackAssemblySloActuals {
    #[must_use]
    pub fn from_pack_run(
        draft: &PackDraft,
        scanned_count: usize,
        graph_edges_traversed: usize,
        elapsed_ms: u64,
    ) -> Self {
        Self {
            candidate_count: draft.selection_audit.candidate_count,
            scanned_count,
            index_generation: None,
            graph_generation: None,
            graph_edges_traversed,
            elapsed_ms,
            memory_bytes_peak: deterministic_pack_memory_bytes_peak(draft, scanned_count),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackAssemblySloStatus {
    WithinBudget,
    Warning,
    Failure,
}

impl PackAssemblySloStatus {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::WithinBudget => "within_budget",
            Self::Warning => "warning",
            Self::Failure => "failure",
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackAssemblySloDegradation {
    pub code: &'static str,
    pub severity: ContextResponseSeverity,
    pub message: String,
    pub repair: Option<String>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackAssemblySlo {
    pub schema: &'static str,
    pub profile: PackResourceProfile,
    pub budget_class: PackSloBudgetClass,
    pub admission: Option<PackAdmissionPosture>,
    pub actuals: PackAssemblySloActuals,
    pub status: PackAssemblySloStatus,
    pub degradations: Vec<PackAssemblySloDegradation>,
}

impl PackAssemblySlo {
    #[must_use]
    pub fn evaluate(profile: PackResourceProfile, actuals: PackAssemblySloActuals) -> Self {
        let budget_class = profile.budget_class();
        let mut degradations = Vec::new();
        let scanned_over_budget = actuals.scanned_count > budget_class.candidates_scanned_max;
        let graph_over_budget =
            actuals.graph_edges_traversed > budget_class.graph_traversal_max_edges;

        let status = if scanned_over_budget || graph_over_budget {
            degradations.push(pack_assembly_budget_exceeded_degradation(
                profile,
                &budget_class,
                &actuals,
            ));
            PackAssemblySloStatus::Failure
        } else if actuals.scanned_count == budget_class.candidates_scanned_max {
            degradations.push(pack_assembly_slow_degradation(
                profile,
                &budget_class,
                &actuals,
            ));
            PackAssemblySloStatus::Warning
        } else {
            PackAssemblySloStatus::WithinBudget
        };

        Self {
            schema: PACK_ASSEMBLY_SLO_SCHEMA_V1,
            profile,
            budget_class,
            admission: Some(PackAdmissionPosture::admitted(
                0,
                budget_class.concurrent_pack_max,
            )),
            actuals,
            status,
            degradations,
        }
    }

    #[must_use]
    pub fn concurrent_limit_reached(
        profile: PackResourceProfile,
        actuals: PackAssemblySloActuals,
        retry_after_ms: u64,
        queue_depth: usize,
    ) -> Self {
        let budget_class = profile.budget_class();
        Self {
            schema: PACK_ASSEMBLY_SLO_SCHEMA_V1,
            profile,
            budget_class,
            admission: Some(PackAdmissionPosture::backoff(
                queue_depth,
                budget_class.concurrent_pack_max,
                retry_after_ms,
            )),
            actuals,
            status: PackAssemblySloStatus::Warning,
            degradations: vec![pack_concurrent_limit_reached_degradation(
                profile,
                &budget_class,
                retry_after_ms,
                queue_depth,
            )],
        }
    }

    #[must_use]
    pub fn context_degradations(&self) -> Vec<ContextResponseDegradation> {
        self.degradations
            .iter()
            .filter_map(|entry| {
                ContextResponseDegradation::new(
                    entry.code,
                    entry.severity,
                    entry.message.clone(),
                    entry.repair.clone(),
                )
                .ok()
            })
            .collect()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ConsensusProducer {
    pub agent_name: Option<String>,
    pub trust_class: TrustClass,
}

#[derive(Clone, Debug, PartialEq)]
pub struct ConsensusEntry {
    pub schema: &'static str,
    pub subject_fingerprint: String,
    pub subject_summary: String,
    pub agreement_score: f32,
    pub member_memory_ids: Vec<MemoryId>,
    pub member_producers: Vec<ConsensusProducer>,
    pub semantic_similarity_min: f32,
    pub first_recorded_at: Option<String>,
    pub last_reinforced_at: Option<String>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ConflictKind {
    Direct,
    StaleReplacement,
    PartialOverlap,
}

impl ConflictKind {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Direct => "direct",
            Self::StaleReplacement => "stale_replacement",
            Self::PartialOverlap => "partial_overlap",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ConflictRecommendedAction {
    Review,
    PromoteOne,
    TombstoneOlder,
    RequestClarification,
}

impl ConflictRecommendedAction {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Review => "review",
            Self::PromoteOne => "promote_one",
            Self::TombstoneOlder => "tombstone_older",
            Self::RequestClarification => "request_clarification",
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ConflictEntry {
    pub schema: &'static str,
    pub subject_fingerprint: String,
    pub kind: ConflictKind,
    pub conflicting_memory_ids: Vec<MemoryId>,
    pub evidence_pointers: Vec<String>,
    pub earliest_at: Option<String>,
    pub latest_at: Option<String>,
    pub recommended_action: ConflictRecommendedAction,
}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct ConsensusConflictReport {
    pub consensus: Vec<ConsensusEntry>,
    pub conflicts: Vec<ConflictEntry>,
}

#[must_use]
pub fn analyze_pack_consensus_conflicts(pack: &PackDraft) -> ConsensusConflictReport {
    let mut groups: BTreeMap<String, Vec<&PackDraftItem>> = BTreeMap::new();
    for item in &pack.items {
        groups
            .entry(subject_key_for_item(item))
            .or_default()
            .push(item);
    }

    let mut report = ConsensusConflictReport::default();
    for (subject_key, mut items) in groups {
        if items.len() < 2 {
            continue;
        }
        items.sort_by_key(|item| item.memory_id);
        let fingerprint = subject_fingerprint(&subject_key);
        if let Some(conflict) = conflict_for_group(&items, &fingerprint) {
            report.conflicts.push(conflict);
        } else if let Some(consensus) = consensus_for_group(&items, &fingerprint) {
            report.consensus.push(consensus);
        }
    }
    report.consensus.sort_by(|left, right| {
        left.subject_fingerprint
            .cmp(&right.subject_fingerprint)
            .then_with(|| left.member_memory_ids.cmp(&right.member_memory_ids))
    });
    report.conflicts.sort_by(|left, right| {
        left.subject_fingerprint
            .cmp(&right.subject_fingerprint)
            .then_with(|| {
                left.conflicting_memory_ids
                    .cmp(&right.conflicting_memory_ids)
            })
    });
    report
}

fn subject_key_for_item(item: &PackDraftItem) -> String {
    item.diversity_key.clone().unwrap_or_else(|| {
        let tokens = normalized_content_tokens(&item.content)
            .into_iter()
            .filter(|token| !SUBJECT_STOP_WORDS.contains(&token.as_str()))
            .take(6)
            .collect::<Vec<_>>();
        if tokens.is_empty() {
            item.memory_id.to_string()
        } else {
            tokens.join(":")
        }
    })
}

fn subject_fingerprint(subject_key: &str) -> String {
    let hash = blake3::hash(format!("ee.consensus.subject.v1:{subject_key}").as_bytes());
    format!("blake3:{}", hash.to_hex())
}

fn consensus_for_group(items: &[&PackDraftItem], fingerprint: &str) -> Option<ConsensusEntry> {
    let semantic_similarity_min = min_pairwise_similarity(items);
    if semantic_similarity_min < 0.85 {
        return None;
    }
    Some(ConsensusEntry {
        schema: CONSENSUS_SCHEMA_V1,
        subject_fingerprint: fingerprint.to_string(),
        subject_summary: subject_summary(items.first().copied()?),
        agreement_score: semantic_similarity_min,
        member_memory_ids: items.iter().map(|item| item.memory_id).collect(),
        member_producers: items.iter().map(|item| producer_for_item(item)).collect(),
        semantic_similarity_min,
        first_recorded_at: earliest_item_time(items),
        last_reinforced_at: latest_item_time(items),
    })
}

fn conflict_for_group(items: &[&PackDraftItem], fingerprint: &str) -> Option<ConflictEntry> {
    let mut best_pair: Option<(&PackDraftItem, &PackDraftItem, ConflictKind)> = None;
    for (left_index, left) in items.iter().enumerate() {
        for right in items.iter().skip(left_index + 1) {
            if is_direct_conflict(left, right) {
                best_pair = Some((left, right, ConflictKind::Direct));
                break;
            }
            if is_stale_replacement_conflict(left, right) {
                best_pair = Some((left, right, ConflictKind::StaleReplacement));
                break;
            }
            if is_partial_overlap(left, right) {
                best_pair = Some((left, right, ConflictKind::PartialOverlap));
            }
        }
        if best_pair.is_some_and(|(_, _, kind)| kind != ConflictKind::PartialOverlap) {
            break;
        }
    }

    let (left, right, kind) = best_pair?;
    let mut memory_ids = vec![left.memory_id, right.memory_id];
    memory_ids.sort();
    Some(ConflictEntry {
        schema: CONFLICT_SCHEMA_V1,
        subject_fingerprint: fingerprint.to_string(),
        kind,
        conflicting_memory_ids: memory_ids,
        evidence_pointers: vec![evidence_pointer(left), evidence_pointer(right)],
        earliest_at: earliest_item_time(&[left, right]),
        latest_at: latest_item_time(&[left, right]),
        recommended_action: recommended_action_for_conflict(left, right, kind),
    })
}

fn producer_for_item(item: &PackDraftItem) -> ConsensusProducer {
    ConsensusProducer {
        agent_name: item.trust.subclass.clone(),
        trust_class: item.trust.class,
    }
}

fn subject_summary(item: &PackDraftItem) -> String {
    let mut summary = item
        .content
        .split_whitespace()
        .take(16)
        .collect::<Vec<_>>()
        .join(" ");
    if summary.len() > 120 {
        summary.truncate(120);
    }
    summary
}

fn evidence_pointer(item: &PackDraftItem) -> String {
    item.provenance.first().map_or_else(
        || format!("ee://memory/{}", item.memory_id),
        |provenance| provenance.uri.to_string(),
    )
}

fn earliest_item_time(items: &[&PackDraftItem]) -> Option<String> {
    items
        .iter()
        .filter_map(|item| item.lifecycle.as_ref())
        .filter_map(|lifecycle| {
            lifecycle
                .valid_from
                .as_ref()
                .or(lifecycle.valid_to.as_ref())
        })
        .min()
        .cloned()
}

fn latest_item_time(items: &[&PackDraftItem]) -> Option<String> {
    items
        .iter()
        .filter_map(|item| item.lifecycle.as_ref())
        .filter_map(|lifecycle| {
            lifecycle
                .valid_from
                .as_ref()
                .or(lifecycle.valid_to.as_ref())
        })
        .max()
        .cloned()
}

fn min_pairwise_similarity(items: &[&PackDraftItem]) -> f32 {
    let mut min_similarity = 1.0_f32;
    for (left_index, left) in items.iter().enumerate() {
        for right in items.iter().skip(left_index + 1) {
            min_similarity = min_similarity.min(content_similarity(&left.content, &right.content));
        }
    }
    min_similarity
}

fn content_similarity(left: &str, right: &str) -> f32 {
    let left_tokens = normalized_content_tokens(left);
    let right_tokens = normalized_content_tokens(right);
    if left_tokens.is_empty() || right_tokens.is_empty() {
        return 0.0;
    }
    let left_set = left_tokens.into_iter().collect::<BTreeSet<_>>();
    let right_set = right_tokens.into_iter().collect::<BTreeSet<_>>();
    let intersection = left_set.intersection(&right_set).count() as f32;
    let union = left_set.union(&right_set).count() as f32;
    if union == 0.0 {
        0.0
    } else {
        intersection / union
    }
}

fn normalized_content_tokens(content: &str) -> Vec<String> {
    content
        .split(|character: char| !character.is_ascii_alphanumeric())
        .filter_map(|token| {
            let token = token.trim().to_ascii_lowercase();
            (token.len() >= 2).then_some(token)
        })
        .collect()
}

fn is_direct_conflict(left: &PackDraftItem, right: &PackDraftItem) -> bool {
    let left_polarity = claim_polarity(&left.content);
    let right_polarity = claim_polarity(&right.content);
    left_polarity != ClaimPolarity::Unknown
        && right_polarity != ClaimPolarity::Unknown
        && left_polarity != right_polarity
        && content_similarity(&left.content, &right.content) >= 0.2
}

fn is_stale_replacement_conflict(left: &PackDraftItem, right: &PackDraftItem) -> bool {
    match (
        version_marker(&left.content),
        version_marker(&right.content),
        earliest_item_time(&[left, right]),
        latest_item_time(&[left, right]),
    ) {
        (Some(left_version), Some(right_version), Some(earliest), Some(latest)) => {
            left_version != right_version
                && earliest != latest
                && content_similarity(&left.content, &right.content) >= 0.2
        }
        _ => false,
    }
}

fn is_partial_overlap(left: &PackDraftItem, right: &PackDraftItem) -> bool {
    let similarity = content_similarity(&left.content, &right.content);
    (0.2..0.85).contains(&similarity)
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ClaimPolarity {
    Positive,
    Negative,
    Unknown,
}

fn claim_polarity(content: &str) -> ClaimPolarity {
    let content = format!(" {} ", content.to_ascii_lowercase());
    if [
        " never ",
        " not ",
        " no ",
        " don't ",
        " do not ",
        " forbid ",
        " forbidden ",
    ]
    .iter()
    .any(|needle| content.contains(needle))
    {
        ClaimPolarity::Negative
    } else if [
        " always ",
        " must ",
        " should ",
        " use ",
        " run ",
        " require ",
    ]
    .iter()
    .any(|needle| content.contains(needle))
    {
        ClaimPolarity::Positive
    } else {
        ClaimPolarity::Unknown
    }
}

fn version_marker(content: &str) -> Option<String> {
    normalized_content_tokens(content)
        .into_iter()
        .find(|token| token.starts_with('v') && token.chars().skip(1).all(|c| c.is_ascii_digit()))
}

fn recommended_action_for_conflict(
    left: &PackDraftItem,
    right: &PackDraftItem,
    kind: ConflictKind,
) -> ConflictRecommendedAction {
    match kind {
        ConflictKind::StaleReplacement => ConflictRecommendedAction::TombstoneOlder,
        ConflictKind::Direct if has_human_vs_agent_assertion(left, right) => {
            ConflictRecommendedAction::PromoteOne
        }
        ConflictKind::Direct => ConflictRecommendedAction::RequestClarification,
        ConflictKind::PartialOverlap => ConflictRecommendedAction::Review,
    }
}

fn has_human_vs_agent_assertion(left: &PackDraftItem, right: &PackDraftItem) -> bool {
    matches!(
        (left.trust.class, right.trust.class),
        (TrustClass::HumanExplicit, TrustClass::AgentAssertion)
            | (TrustClass::AgentAssertion, TrustClass::HumanExplicit)
            | (TrustClass::PeerHumanAttested, TrustClass::AgentAssertion)
            | (TrustClass::AgentAssertion, TrustClass::PeerHumanAttested)
    )
}

const SUBJECT_STOP_WORDS: &[&str] = &[
    "always", "before", "check", "do", "does", "for", "in", "must", "never", "not", "release",
    "run", "should", "the", "use",
];

#[derive(Clone, Debug, PartialEq)]
pub struct ContextResponse {
    pub schema: &'static str,
    pub success: bool,
    pub data: ContextResponseData,
    pub cached_json: Option<String>,
}

impl ContextResponse {
    /// Build a stable successful `ee pack` response.
    ///
    /// # Errors
    ///
    /// Returns [`PackValidationError::ContextResponseQueryMismatch`] if
    /// the request query and draft query differ. A response must carry
    /// exactly the request that produced the pack so later `ee why`
    /// explanations can trust the provenance chain.
    pub fn new(
        request: ContextRequest,
        pack: PackDraft,
        degraded: Vec<ContextResponseDegradation>,
    ) -> Result<Self, PackValidationError> {
        if request.query != pack.query {
            return Err(PackValidationError::ContextResponseQueryMismatch {
                request_query: request.query,
                draft_query: pack.query,
            });
        }
        Ok(Self {
            schema: RESPONSE_SCHEMA_V2,
            success: true,
            cached_json: None,
            data: ContextResponseData {
                command: PACK_COMMAND,
                embed_backend: EmbedBackend::HashFallback,
                request,
                pack,
                agent_profile: None,
                slo: None,
                scope_stats: None,
                consensus: Vec::new(),
                conflicts: Vec::new(),
                coordination: None,
                mesh: None,
                pack_dna: None,
                adaptive_budget: None,
                pagination: None,
                degraded,
            },
        })
    }

    #[must_use]
    pub fn from_cached_json(request: ContextRequest, cached_json: String) -> Self {
        Self::from_cached_json_with_command(request, cached_json, PACK_COMMAND)
    }

    #[must_use]
    pub fn from_cached_json_with_command(
        request: ContextRequest,
        cached_json: String,
        command: &'static str,
    ) -> Self {
        let embed_backend = cached_context_embed_backend(&cached_json);
        Self {
            schema: RESPONSE_SCHEMA_V2,
            success: true,
            cached_json: Some(cached_json),
            data: ContextResponseData {
                command,
                embed_backend,
                request: request.clone(),
                pack: PackDraft {
                    query: request.query.clone(),
                    budget: request.budget,
                    used_tokens: 0,
                    items: Vec::new(),
                    evidence_items: Vec::new(),
                    omitted: Vec::new(),
                    selection_audit: PackSelectionAudit {
                        profile: request.profile,
                        objective: PackSelectionObjective::MmrRedundancy,
                        algorithm_id: "cached_context_response_v1",
                        algorithm_description: "Context response served from the L2 pack cache.",
                        candidate_count: 0,
                        selected_count: 0,
                        omitted_count: 0,
                        budget_limit: request.budget.max_tokens(),
                        budget_used: 0,
                        total_objective_value: 0.0,
                        monotone: false,
                        submodular: false,
                        selected_items: Vec::new(),
                        steps: Vec::new(),
                    },
                    hash: None,
                },
                agent_profile: None,
                slo: None,
                scope_stats: None,
                consensus: Vec::new(),
                conflicts: Vec::new(),
                coordination: None,
                mesh: None,
                pack_dna: None,
                adaptive_budget: None,
                pagination: None,
                degraded: Vec::new(),
            },
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ContextResponseData {
    pub command: &'static str,
    pub embed_backend: EmbedBackend,
    pub request: ContextRequest,
    pub pack: PackDraft,
    pub agent_profile: Option<serde_json::Value>,
    pub slo: Option<PackAssemblySlo>,
    pub scope_stats: Option<MemoryScopeStats>,
    pub consensus: Vec<ConsensusEntry>,
    pub conflicts: Vec<ConflictEntry>,
    pub coordination: Option<PackCoordinationSnapshot>,
    pub mesh: Option<PackRevisionMeshMetadata>,
    pub pack_dna: Option<serde_json::Value>,
    pub adaptive_budget: Option<budget_classifier::AdaptiveBudgetDecision>,
    pub pagination: Option<ContextResponsePagination>,
    pub degraded: Vec<ContextResponseDegradation>,
}

fn cached_context_embed_backend(cached_json: &str) -> EmbedBackend {
    serde_json::from_str::<serde_json::Value>(cached_json)
        .ok()
        .and_then(|value| {
            value
                .pointer("/data/embed_backend")
                .and_then(serde_json::Value::as_str)
                .and_then(|value| value.parse().ok())
        })
        .unwrap_or_default()
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ContextResponsePagination {
    pub offset: u32,
    pub limit: u32,
    pub total: u32,
    pub page_size: u32,
    pub has_more: bool,
    pub next_cursor: Option<String>,
}

impl ContextResponseData {
    #[must_use]
    pub fn advisory_banner(&self) -> PackAdvisoryBanner {
        context_advisory_banner(&self.pack, &self.degraded)
    }

    #[must_use]
    pub(crate) fn advisory_banner_for_degraded(
        &self,
        degraded: &[ContextResponseDegradation],
    ) -> PackAdvisoryBanner {
        context_advisory_banner(&self.pack, degraded)
    }
}

fn team_pack_provenance(
    trust: &PackTrustSignal,
) -> Option<crate::core::memory_scope::TeamProvenance> {
    crate::core::memory_scope::team_provenance_from_trust(
        trust.class.as_str(),
        trust.subclass.as_deref(),
        None,
    )
}

fn team_pack_attribution_suffix(trust: &PackTrustSignal) -> Option<String> {
    Some(team_pack_provenance(trust)?.compact_suffix())
}

/// JSON `teamProvenance` for pack items. Same block search emits on hits.
#[must_use]
pub fn team_pack_provenance_json(trust: &PackTrustSignal) -> Option<String> {
    serde_json::to_string(&team_pack_provenance(trust)?.to_json()).ok()
}

/// Render a context response as the canonical Markdown prompt fragment.
#[must_use]
pub fn render_context_response_markdown(response: &ContextResponse) -> String {
    render_context_response_markdown_with_degraded(response, &response.data.degraded)
}

#[must_use]
pub(crate) fn render_context_response_markdown_with_degraded(
    response: &ContextResponse,
    degraded: &[ContextResponseDegradation],
) -> String {
    let mut body = render_context_markdown_with_analysis(
        &response.data.request,
        &response.data.pack,
        degraded,
        &response.data.consensus,
        &response.data.conflicts,
        response.data.coordination.as_ref(),
    );
    // Bead bd-17c65.4.3 (D3): append pack metadata as trailing HTML
    // comments. Invisible to standard markdown rendering and to LLMs
    // (they're treated as inline noise) but trivially greppable by
    // tools that need to correlate a piped/logged markdown body back
    // to the structured pack record without re-querying.
    //
    // Two fields, one per line, on consecutive trailing lines so grep
    // tooling can parse with a fixed-prefix regex:
    //   <!-- pack.hash: blake3:... -->
    //   <!-- pack.schema: ee.response.v2 -->
    //
    // The `pack.hash` value is whatever the pack record carries (None
    // -> the literal string "absent" so the line is always present and
    // greppable). `pack.schema` is the response envelope schema the
    // body adheres to.
    //
    // The D3 acceptance text also listed `pack.generatedAt`, but the
    // body is rendered via this function twice on every context call
    // (once for the standalone --format markdown output, once as the
    // `pack.text` JSON field), and embedding a wall-clock timestamp
    // would break the A4 byte-equivalence invariant between those two
    // projections. The response envelope already carries `generatedAt`
    // semantics at the surface layer (audit log + pack record), so
    // omitting it here is a sound trade — correlation by `pack.hash`
    // is sufficient for the "find this body's structured record"
    // use case D3 describes.
    let pack_hash = response.data.pack.hash.as_deref().unwrap_or("absent");
    body.push_str(&format!("\n<!-- pack.hash: {pack_hash} -->\n"));
    body.push_str(&format!("<!-- pack.schema: {} -->\n", response.schema));
    body
}

/// Render the canonical Markdown prompt fragment from context pack parts.
#[must_use]
pub fn render_context_markdown(
    request: &ContextRequest,
    pack: &PackDraft,
    degraded: &[ContextResponseDegradation],
) -> String {
    render_context_markdown_with_analysis(request, pack, degraded, &[], &[], None)
}

#[must_use]
/// A link-only LOD pack item: `link_only_lod_candidate` replaced its body with
/// the deterministic `Memory <id>` stub (or the bare id). Such items render in
/// the peripheral-vision index rather than inline with full/preview content.
fn is_link_only_pack_item(item: &PackDraftItem) -> bool {
    let memory_id = item.memory_id.to_string();
    item.content == format!("Memory {memory_id}") || item.content == memory_id
}

pub fn render_context_markdown_with_analysis(
    request: &ContextRequest,
    pack: &PackDraft,
    degraded: &[ContextResponseDegradation],
    consensus: &[ConsensusEntry],
    conflicts: &[ConflictEntry],
    coordination: Option<&PackCoordinationSnapshot>,
) -> String {
    let mut output = String::new();

    output.push_str(&format!(
        "# Context Pack: {}\n\n",
        escape_markdown_heading(&request.query)
    ));

    output.push_str(&format!(
        "**Profile:** {} | **Budget:** {}/{} tokens\n\n",
        request.profile.as_str(),
        pack.used_tokens,
        pack.budget.max_tokens()
    ));

    let advisory_banner = context_advisory_banner(pack, degraded);
    output.push_str("## Advisory Memory Banner\n\n");
    output.push_str(&format!(
        "**Status:** `{}`\n\n",
        advisory_banner.status.as_str()
    ));
    output.push_str(&escape_markdown_text(&advisory_banner.summary));
    output.push_str("\n\n");
    if !advisory_banner.notes.is_empty() {
        for note in &advisory_banner.notes {
            output.push_str(&format!(
                "- **{}** {} {} Action: {}\n",
                note.severity.as_str(),
                markdown_inline_code(note.code),
                escape_markdown_text(&note.message),
                markdown_inline_code(note.action)
            ));
        }
        output.push('\n');
    }

    if !consensus.is_empty() || !conflicts.is_empty() {
        output.push_str("## Consensus and Conflicts\n\n");
        for entry in consensus {
            output.push_str(&format!(
                "- **Consensus:** {} ({}) across {} memories.\n",
                escape_markdown_text(&entry.subject_summary),
                markdown_inline_code(&entry.subject_fingerprint),
                entry.member_memory_ids.len()
            ));
        }
        for entry in conflicts {
            output.push_str(&format!(
                "- **Conflict:** {} {}; action: {}.\n",
                markdown_inline_code(entry.kind.as_str()),
                markdown_inline_code(&entry.subject_fingerprint),
                markdown_inline_code(entry.recommended_action.as_str())
            ));
        }
        output.push('\n');
    }

    if let Some(coordination) = coordination {
        render_coordination_markdown(&mut output, coordination);
    }

    let peripheral_items: Vec<&PackDraftItem> = pack
        .items
        .iter()
        .filter(|item| is_link_only_pack_item(item))
        .collect();

    if pack.items.is_empty() && pack.evidence_items.is_empty() {
        output.push_str("*No items in pack.*\n\n");
    } else {
        let mut by_section: std::collections::HashMap<&str, Vec<&PackDraftItem>> =
            std::collections::HashMap::new();
        let mut section_order: Vec<&str> = Vec::new();
        for item in &pack.items {
            // Link-only LOD items render in the peripheral index below, not
            // inline with full/preview content.
            if is_link_only_pack_item(item) {
                continue;
            }
            let section = context_render_section_key(item);
            if !by_section.contains_key(section) {
                section_order.push(section);
            }
            by_section.entry(section).or_default().push(item);
        }

        let mut display_index: u32 = 0;
        for section in section_order {
            let Some(items) = by_section.get(section) else {
                continue;
            };
            output.push_str(&format!("## {}\n\n", context_section_display_name(section)));
            for item in items {
                display_index += 1;
                output.push_str(&format!(
                    "### {}. {} ({} tokens)\n\n",
                    display_index,
                    escape_markdown_text(&item.memory_id.to_string()),
                    item.estimated_tokens
                ));

                if !item.content.is_empty() {
                    output.push_str(&markdown_fenced_code_block(&item.content));
                    output.push('\n');
                }

                if !item.why.is_empty() {
                    output.push_str(&format!("**Why:** {}\n\n", escape_markdown_text(&item.why)));
                }

                output.push_str(&format!(
                    "**Trust:** `{}` / `{}`\n\n",
                    item.trust.class.as_str(),
                    item.trust.posture().as_str()
                ));
                if let Some(suffix) = team_pack_attribution_suffix(&item.trust) {
                    output.push_str(&format!("{}\n\n", escape_markdown_text(&suffix)));
                }

                if !item.provenance.is_empty() {
                    output.push_str("**Provenance:**\n");
                    for prov in item.rendered_provenance() {
                        output.push_str(&format!(
                            "- {} ({})\n",
                            markdown_inline_code(&prov.uri),
                            escape_markdown_text(&prov.scheme)
                        ));
                    }
                    output.push('\n');
                }
            }
        }

        if !pack.evidence_items.is_empty() {
            output.push_str("## Evidence\n\n");
            for item in &pack.evidence_items {
                display_index = display_index.saturating_add(1);
                output.push_str(&format!(
                    "### {}. {} ({} tokens)\n\n",
                    display_index,
                    escape_markdown_text(&item.evidence_id),
                    item.estimated_tokens
                ));
                if !item.content.is_empty() {
                    output.push_str(&markdown_fenced_code_block(&item.content));
                    output.push('\n');
                }
                if !item.why.is_empty() {
                    output.push_str(&format!("**Why:** {}\n\n", escape_markdown_text(&item.why)));
                }
                output.push_str(&format!(
                    "**Trust:** `{}` / `{}`\n\n",
                    item.trust.class.as_str(),
                    item.trust.posture().as_str()
                ));
                if !item.provenance.is_empty() {
                    output.push_str("**Provenance:**\n");
                    for provenance in item.rendered_provenance() {
                        output.push_str(&format!(
                            "- {} ({})\n",
                            markdown_inline_code(&provenance.uri),
                            escape_markdown_text(&provenance.scheme)
                        ));
                    }
                    output.push('\n');
                }
            }
        }
    }

    if !peripheral_items.is_empty() {
        output.push_str("## Peripheral Index\n\n");
        output.push_str(
            "Link-only memories carried as a peripheral-vision index; drill in with `ee memory show <id>`.\n\n",
        );
        for item in &peripheral_items {
            output.push_str(&format!(
                "- {} ({})\n",
                markdown_inline_code(&item.memory_id.to_string()),
                context_section_display_name(item.section.as_str())
            ));
        }
        output.push('\n');
    }

    if !pack.omitted.is_empty() {
        output.push_str("## Omitted\n\n");
        for omission in &pack.omitted {
            output.push_str(&format!(
                "- {} ({} tokens) — {}\n",
                escape_markdown_text(&omission.memory_id.to_string()),
                omission.estimated_tokens,
                escape_markdown_text(omission.reason.as_str())
            ));
        }
        output.push('\n');
    }

    if !degraded.is_empty() {
        output.push_str("## Degradations\n\n");
        for d in degraded {
            output.push_str(&format!(
                "- **[{}]** {}\n",
                d.severity.as_str(),
                escape_markdown_text(&d.message)
            ));
            if let Some(repair) = &d.repair {
                output.push_str(&format!("  - *Repair:* {}\n", markdown_inline_code(repair)));
            }
        }
        output.push('\n');
    }

    output.push_str("---\n\n");
    let query_arg = context_footer_query_arg(&request.query);
    let command = format!("ee pack {query_arg} --format markdown");
    output.push_str(&format!(
        "*Generated by {}*\n",
        markdown_inline_code(&command)
    ));

    output
}

fn context_footer_query_arg(query: &str) -> String {
    if context_footer_double_quotes_are_safe(query) {
        format!("\"{query}\"")
    } else {
        shell_quote(query)
    }
}

fn context_footer_double_quotes_are_safe(query: &str) -> bool {
    !query.is_empty()
        && query.chars().all(|ch| {
            ch.is_ascii_alphanumeric()
                || matches!(
                    ch,
                    ' ' | '.' | ',' | ':' | ';' | '-' | '_' | '/' | '+' | '=' | '?' | '@' | '%'
                )
        })
}

fn render_coordination_markdown(output: &mut String, coordination: &PackCoordinationSnapshot) {
    output.push_str("## Coordination\n\n");
    output.push_str(&format!(
        "**Status:** `{}` | **Sources:** {} | **Conflicts:** {} | **Reservations:** {} | **In-progress Beads:** {}\n\n",
        coordination.freshness.status,
        coordination.summary.source_count,
        coordination.summary.active_conflict_count,
        coordination.summary.active_reservation_count,
        coordination.summary.in_progress_bead_count
    ));

    for source in coordination
        .sources
        .iter()
        .filter(|source| source.stale || source.status != "fresh" || !source.degraded.is_empty())
        .take(4)
    {
        output.push_str(&format!(
            "- **Source:** {} is `{}`",
            markdown_inline_code(&source.kind),
            source.status
        ));
        if source.stale {
            output.push_str(" and stale");
        }
        output.push_str(".\n");
    }

    let conflicts = coordination.active_conflict_entries();
    for entry in conflicts.iter().take(6) {
        output.push_str(&format!(
            "- **Conflict:** {} ({})\n",
            escape_markdown_text(&entry.summary),
            markdown_inline_code(&entry.id)
        ));
    }

    if conflicts.len() > 6 {
        output.push_str(&format!(
            "- **Conflict:** {} additional coordination conflict{} omitted.\n",
            conflicts.len() - 6,
            if conflicts.len() == 7 { "" } else { "s" }
        ));
    }

    let mut rendered_notable = 0_usize;
    for entry in coordination.notable_entries() {
        if entry.conflict {
            continue;
        }
        if rendered_notable >= 6 {
            break;
        }
        rendered_notable = rendered_notable.saturating_add(1);
        output.push_str(&format!(
            "- **{}:** {} ({})\n",
            escape_markdown_text(&entry.kind),
            escape_markdown_text(&entry.summary),
            markdown_inline_code(&entry.id)
        ));
    }

    output.push('\n');
}

fn context_advisory_banner(
    pack: &PackDraft,
    degraded: &[ContextResponseDegradation],
) -> PackAdvisoryBanner {
    let counts = pack.trust_counts();
    let mut notes = Vec::new();

    if counts.advisory() > 0 {
        notes.push(PackAdvisoryNote {
            code: "advisory_memory",
            severity: ContextResponseSeverity::Medium,
            message: format!(
                "{} packed memor{} from agent assertions or CASS evidence and must be validated against provenance before being treated as policy.",
                counts.advisory(),
                plural_suffix(counts.advisory(), "y", "ies")
            ),
            memory_ids: memory_ids_for_posture(pack, PackTrustPosture::Advisory),
            action: "validate_provenance_before_following",
        });
    }

    if counts.legacy() > 0 {
        notes.push(PackAdvisoryNote {
            code: "legacy_memory",
            severity: ContextResponseSeverity::High,
            message: format!(
                "{} packed legacy memor{} from pre-v1 imports and is evidence only until revalidated.",
                counts.legacy(),
                plural_suffix(counts.legacy(), "y", "ies")
            ),
            memory_ids: memory_ids_for_posture(pack, PackTrustPosture::LegacyEvidence),
            action: "revalidate_legacy_memory_before_use",
        });
    }

    // Bead bd-17c65.5.2 (E2): the meta-`degraded_context` summary
    // note was deleted here too. Same rationale as the matching site
    // above on `PackBuilder::advisory_banner`. Status decision still
    // fires on any affecting degradation (filtered by category).

    let status = if degraded.iter().any(|d| d.category().included_by_default()) {
        PackAdvisoryStatus::Degraded
    } else if counts.advisory() > 0 || counts.legacy() > 0 {
        PackAdvisoryStatus::Advisory
    } else {
        PackAdvisoryStatus::Clear
    };

    PackAdvisoryBanner {
        status,
        summary: advisory_summary(status, &counts, degraded),
        authoritative_count: counts.authoritative(),
        advisory_count: counts.advisory(),
        legacy_count: counts.legacy(),
        degradation_count: degraded.len(),
        notes,
    }
}

fn context_section_display_name(section: &str) -> &str {
    match section {
        "what_not_to_do" => "What NOT to do",
        "core" => "Core",
        "supporting" => "Supporting",
        "procedural" => "Procedural",
        "background" => "Background",
        "example" => "Example",
        other => other,
    }
}

fn context_render_section_key(item: &PackDraftItem) -> &str {
    if item.section == PackSection::Failures
        && item.selected_in == PackSelectionPhase::AntiPatternFirst
    {
        "what_not_to_do"
    } else {
        item.section.as_str()
    }
}

fn escape_markdown_text(input: &str) -> String {
    let mut output = String::with_capacity(input.len());
    let chars: Vec<char> = input.chars().collect();
    let mut line_start = true;
    let mut digits_at_line_start: usize = 0;
    let mut i = 0;
    while i < chars.len() {
        let ch = chars[i];
        let prev_ch = if i > 0 { Some(chars[i - 1]) } else { None };
        let next_ch = chars.get(i + 1).copied();
        match ch {
            '\\' => output.push_str("\\\\"),
            '&' => output.push_str("&amp;"),
            '<' => output.push_str("&lt;"),
            '>' => output.push_str("&gt;"),
            '`' => {
                output.push('\\');
                output.push('`');
            }
            '\n' => {
                output.push('\n');
                line_start = true;
                digits_at_line_start = 0;
                i += 1;
                continue;
            }
            '\r' => {
                i += 1;
                continue;
            }
            '#' if line_start => {
                output.push('\\');
                output.push('#');
            }
            '+' if line_start && markdown_next_is_space_or_eol(next_ch) => {
                output.push('\\');
                output.push('+');
            }
            '=' if line_start && markdown_line_is_marker_run(&chars, i, '=', 1) => {
                output.push('\\');
                output.push('=');
            }
            '-' if line_start
                && (markdown_next_is_space_or_eol(next_ch)
                    || markdown_line_is_marker_run(&chars, i, '-', 3)) =>
            {
                output.push('\\');
                output.push('-');
            }
            '.' if line_start
                && digits_at_line_start > 0
                && markdown_next_is_space_or_eol(next_ch) =>
            {
                output.push('\\');
                output.push('.');
            }
            ')' if line_start
                && digits_at_line_start > 0
                && markdown_next_is_space_or_eol(next_ch) =>
            {
                output.push('\\');
                output.push(')');
            }
            '!' if next_ch == Some('[') => {
                output.push('\\');
                output.push('!');
            }
            '[' | ']' => {
                output.push('\\');
                output.push(ch);
            }
            '*' | '_' => {
                if markdown_emphasis_eligible(prev_ch, next_ch) {
                    output.push('\\');
                    output.push(ch);
                } else {
                    output.push(ch);
                }
            }
            '~' if prev_ch == Some('~') || next_ch == Some('~') => {
                output.push('\\');
                output.push('~');
            }
            other => output.push(other),
        }
        if line_start {
            if ch.is_ascii_digit() {
                digits_at_line_start += 1;
            } else if !ch.is_ascii_whitespace() {
                line_start = false;
                digits_at_line_start = 0;
            }
        }
        i += 1;
    }
    output
}

fn escape_markdown_heading(input: &str) -> String {
    escape_markdown_text(&input.split_whitespace().collect::<Vec<_>>().join(" "))
}

fn markdown_inline_code(input: &str) -> String {
    let normalized = input.replace(['\r', '\n'], " ");
    let delimiter = "`".repeat(
        markdown_longest_backtick_run(&normalized)
            .saturating_add(1)
            .max(1),
    );
    let needs_padding = normalized.starts_with('`')
        || normalized.ends_with('`')
        || normalized.starts_with(' ')
        || normalized.ends_with(' ');
    let padding = if needs_padding { " " } else { "" };
    format!("{delimiter}{padding}{normalized}{padding}{delimiter}")
}

fn markdown_fenced_code_block(content: &str) -> String {
    let delimiter = "`".repeat(
        markdown_longest_backtick_run(content)
            .saturating_add(1)
            .max(3),
    );
    let mut output = String::with_capacity(content.len() + delimiter.len() * 2 + 4);
    output.push_str(&delimiter);
    output.push('\n');
    output.push_str(content);
    if !content.ends_with('\n') {
        output.push('\n');
    }
    output.push_str(&delimiter);
    output.push('\n');
    output
}

fn markdown_longest_backtick_run(input: &str) -> usize {
    let mut current = 0;
    let mut longest = 0;
    for ch in input.chars() {
        if ch == '`' {
            current += 1;
            longest = longest.max(current);
        } else {
            current = 0;
        }
    }
    longest
}

fn markdown_emphasis_eligible(prev: Option<char>, next: Option<char>) -> bool {
    let prev_is_word = prev.is_some_and(|c| c.is_alphanumeric() || c == '_');
    let next_is_word = next.is_some_and(|c| c.is_alphanumeric() || c == '_');
    !(prev_is_word && next_is_word)
}

fn markdown_next_is_space_or_eol(next: Option<char>) -> bool {
    match next {
        None => true,
        Some(ch) => ch == ' ' || ch == '\t' || ch == '\n',
    }
}

fn markdown_line_is_marker_run(
    chars: &[char],
    start: usize,
    marker: char,
    min_count: usize,
) -> bool {
    let mut count = 0;
    let mut index = start;
    while index < chars.len() {
        match chars[index] {
            ch if ch == marker => count += 1,
            ' ' | '\t' => {}
            '\n' | '\r' => break,
            _ => return false,
        }
        index += 1;
    }
    count >= min_count
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ContextResponseDegradation {
    pub code: String,
    pub severity: ContextResponseSeverity,
    pub message: String,
    pub repair: Option<String>,
}

impl ContextResponseDegradation {
    /// Build a validated degradation entry for a context response.
    ///
    /// # Errors
    ///
    /// Returns a [`PackValidationError`] when `code` or `message` is
    /// empty after trimming.
    pub fn new(
        code: impl Into<String>,
        severity: ContextResponseSeverity,
        message: impl Into<String>,
        repair: Option<String>,
    ) -> Result<Self, PackValidationError> {
        let code = trim_required(code.into(), PackValidationError::EmptyDegradationCode)?;
        let message = trim_required(
            message.into(),
            PackValidationError::EmptyDegradationMessage { code: code.clone() },
        )?;
        Ok(Self {
            code,
            severity,
            message,
            repair: repair
                .map(|value| value.trim().to_string())
                .filter(|value| !value.is_empty()),
        })
    }

    /// Category for this degradation — whether it affects this
    /// response, describes workspace state, or describes a build-time
    /// feature gap. See [`DegradedCategory`] and [`category_for_code`].
    ///
    /// Bead bd-17c65.5.2 (E2).
    #[must_use]
    pub fn category(&self) -> DegradedCategory {
        category_for_code(&self.code)
    }
}

/// Categorization for a degraded signal (bead bd-17c65.5.2 / E2).
///
/// Determines whether the current response was actually affected by the
/// signal, or whether the signal describes a build-time gap or
/// workspace-state condition that is unrelated to this particular
/// response. The advisoryBanner and emitted `degraded[]` array filter
/// out non-affecting signals by default — agents reading `degraded: []`
/// can infer that everything worked exactly as documented.
///
/// The categorization is a deterministic, pure function of the code
/// string (see [`category_for_code`]); each known code is mapped
/// explicitly, and unknown codes default to `AffectsThisResponse` so a
/// new code that has not been categorized yet is conservatively
/// surfaced rather than silently filtered.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DegradedCategory {
    /// The signal directly describes a fact about the response that was
    /// just produced: the semantic embedder timed out, the pack fell
    /// back to lexical-only, the search dropped duplicates, the query
    /// returned no relevant results, etc. ALWAYS emitted.
    AffectsThisResponse,
    /// The signal describes a workspace-state condition that is not
    /// specific to the response (the index is mildly behind writes,
    /// the cass binary is unavailable, the graph snapshot is stale but
    /// the current command did not consume graph data). DROPPED from
    /// per-response degraded[] by default; surfaces via `ee status` or
    /// when the caller passes `--include-non-affecting-degradations`.
    WorkspaceStateNotPerResponse,
    /// The signal describes a feature that was not compiled into the
    /// binary (e.g. `graph_snapshot_unimplemented`,
    /// `mcp_feature_disabled`). Belongs in `ee capabilities`, NOT in
    /// per-response `degraded[]`. DROPPED by default.
    BuildTimeFeatureGap,
}

impl DegradedCategory {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::AffectsThisResponse => "affects_this_response",
            Self::WorkspaceStateNotPerResponse => "workspace_state_not_per_response",
            Self::BuildTimeFeatureGap => "build_time_feature_gap",
        }
    }

    /// Whether this category should be included in per-response
    /// `degraded[]` by default. `true` only for `AffectsThisResponse`.
    #[must_use]
    pub const fn included_by_default(self) -> bool {
        matches!(self, Self::AffectsThisResponse)
    }
}

/// Pure, deterministic mapping from a degraded code string to its
/// category. Unknown codes default to [`DegradedCategory::AffectsThisResponse`]
/// so a new code that has not been categorized yet is surfaced rather
/// than silently filtered.
///
/// Adding a new code requires either (a) accepting the conservative
/// `AffectsThisResponse` default, OR (b) adding an explicit row here.
/// The categorization unit test (`tests/diagnostics_banner_categorization_unit.rs`)
/// asserts every code observed in the codebase appears with an
/// explicit category, so a new code that should be filtered fails CI
/// until the table is updated.
///
/// Bead bd-17c65.5.2 (E2).
#[must_use]
pub const fn category_for_code(code: &str) -> DegradedCategory {
    // const fn cannot use str comparison directly; expand to a match on
    // byte slices. Each arm is a known code → its category.
    match code.as_bytes() {
        // Build-time feature gaps — feature was not compiled into the
        // binary. Belongs in `ee capabilities`, NOT per-response.
        b"graph_snapshot_unimplemented"
        | b"mcp_feature_disabled"
        | b"mcp_unavailable"
        | b"diagram_backend_unavailable" => DegradedCategory::BuildTimeFeatureGap,

        // Workspace state — observable via `ee status`, not specific
        // to the current response.
        b"search_index_stale"
        | b"index_stale"
        | b"index_missing"
        | b"index_corrupt"
        | b"index_locked"
        | b"cass_unavailable"
        | b"graph_snapshot_missing"
        | b"graph_snapshot_stale"
        | b"graph_snapshot_topology_unavailable"
        | b"graph_snapshot_unusable"
        | b"graph_unavailable"
        // A graph feature (proximity-to-seed, PPR rerank) being disabled by config is a
        // workspace-config state, observable via `ee config`/`ee capabilities`, not a
        // per-response content degradation. It is OFF BY DEFAULT, so emitting it as an
        // AffectsThisResponse degradation falsely flips the pack advisory banner on every
        // healthy pack. (Fix: false "degraded" banner on healthy packs.)
        | b"graph_feature_disabled"
        | b"agent_detection_unavailable"
        | b"model_registry_empty"
        | b"model_registry_no_available_entry"
        | b"rerank_model_missing"
        | b"rerank_model_corrupt" => DegradedCategory::WorkspaceStateNotPerResponse,

        // Everything else affects the current response (the safe
        // default for unknown codes too).
        _ => DegradedCategory::AffectsThisResponse,
    }
}

fn pack_assembly_slow_degradation(
    profile: PackResourceProfile,
    budget: &PackSloBudgetClass,
    actuals: &PackAssemblySloActuals,
) -> PackAssemblySloDegradation {
    PackAssemblySloDegradation {
        code: PACK_ASSEMBLY_SLOW_CODE,
        severity: ContextResponseSeverity::Low,
        message: format!(
            "Pack assembly reached the {} resource-profile warning threshold: scanned {} candidate{} in {} ms.",
            profile.as_str(),
            actuals.scanned_count,
            plural_s(actuals.scanned_count),
            actuals.elapsed_ms
        ),
        repair: Some(format!(
            "Use --resource-profile swarm_heavy or reduce --candidate-pool below {}.",
            budget.candidates_scanned_max
        )),
    }
}

fn pack_assembly_budget_exceeded_degradation(
    profile: PackResourceProfile,
    budget: &PackSloBudgetClass,
    actuals: &PackAssemblySloActuals,
) -> PackAssemblySloDegradation {
    PackAssemblySloDegradation {
        code: PACK_ASSEMBLY_BUDGET_EXCEEDED_CODE,
        severity: ContextResponseSeverity::Medium,
        message: format!(
            "Pack assembly exceeded the {} resource-profile budget: scanned {}/{} candidates, traversed {}/{} graph edges, elapsed {} ms.",
            profile.as_str(),
            actuals.scanned_count,
            budget.candidates_scanned_max,
            actuals.graph_edges_traversed,
            budget.graph_traversal_max_edges,
            actuals.elapsed_ms
        ),
        repair: Some(
            "Use --resource-profile swarm_heavy, reduce --candidate-pool, or narrow the query."
                .to_string(),
        ),
    }
}

fn pack_concurrent_limit_reached_degradation(
    profile: PackResourceProfile,
    budget: &PackSloBudgetClass,
    retry_after_ms: u64,
    queue_depth: usize,
) -> PackAssemblySloDegradation {
    PackAssemblySloDegradation {
        code: PACK_CONCURRENT_LIMIT_REACHED_CODE,
        severity: ContextResponseSeverity::Low,
        message: format!(
            "Concurrent pack limit reached for the {} resource profile: queue depth {} meets the configured cap of {} pack slot{}.",
            profile.as_str(),
            queue_depth,
            budget.concurrent_pack_max,
            plural_s(budget.concurrent_pack_max)
        ),
        repair: Some(format!(
            "Wait and retry in about {retry_after_ms} ms, reduce concurrent ee context calls, or use --resource-profile swarm_heavy."
        )),
    }
}

fn deterministic_pack_memory_bytes_peak(draft: &PackDraft, scanned_count: usize) -> u64 {
    let item_bytes = draft.items.iter().fold(0_u64, |total, item| {
        total
            .saturating_add(usize_to_u64(item.content.len()))
            .saturating_add(usize_to_u64(item.why.len()))
            .saturating_add(usize_to_u64(item.provenance.len()).saturating_mul(128))
            .saturating_add(256)
    });
    let omitted_bytes = usize_to_u64(draft.omitted.len()).saturating_mul(128);
    let scanned_bytes = usize_to_u64(scanned_count).saturating_mul(256);
    item_bytes
        .saturating_add(omitted_bytes)
        .saturating_add(scanned_bytes)
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackSelectionPhase {
    AntiPatternFirst,
    StrictMmr,
    CoverageFill,
    FacilityLocation,
}

impl PackSelectionPhase {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::AntiPatternFirst => "anti_pattern_first",
            Self::StrictMmr => "strict_mmr",
            Self::CoverageFill => "coverage_fill",
            Self::FacilityLocation => "facility_location",
        }
    }
}

impl fmt::Display for PackSelectionPhase {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackDraftItem {
    pub rank: u32,
    pub memory_id: MemoryId,
    pub section: PackSection,
    pub content: String,
    pub estimated_tokens: u32,
    pub relevance: UnitScore,
    pub utility: UnitScore,
    pub proximity_to_seed: Option<f32>,
    pub score_breakdown: Option<PackScoreBreakdown>,
    pub attempt_family_multiplicity: Option<PackAttemptFamilyMultiplicitySnapshot>,
    pub provenance: Vec<PackProvenance>,
    pub why: String,
    pub diversity_key: Option<String>,
    pub trust: PackTrustSignal,
    pub redactions: Vec<PackItemRedaction>,
    pub tombstoned_at: Option<String>,
    pub lifecycle: Option<PackItemLifecycle>,
    pub freshness_facets: Vec<PackFreshnessFacet>,
    pub selected_in: PackSelectionPhase,
}

/// A live-admitted imported transcript excerpt selected directly into a pack.
///
/// This is deliberately not a `PackDraftItem`: the latter is a memory-shaped
/// type and carries a mandatory `MemoryId`. Keeping the entity typed prevents
/// fresh CASS evidence from being assigned a synthetic memory identity.
#[derive(Clone, Debug, PartialEq)]
pub struct PackEvidenceItem {
    pub rank: u32,
    pub evidence_id: String,
    pub entity_revision: String,
    pub session_id: String,
    pub start_line: u32,
    pub end_line: u32,
    pub section: PackSection,
    pub content: String,
    pub estimated_tokens: u32,
    pub relevance: UnitScore,
    pub utility: UnitScore,
    pub provenance: Vec<PackProvenance>,
    pub why: String,
    pub trust: PackTrustSignal,
}

impl PackEvidenceItem {
    #[must_use]
    pub fn rendered_provenance(&self) -> Vec<RenderedPackProvenance> {
        self.provenance
            .iter()
            .map(PackProvenance::rendered)
            .collect()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackFreshnessFacet {
    pub kind: String,
    pub freshness: String,
    pub stale_anchor: bool,
    pub drift_status: String,
    pub severity: String,
    pub top_reason: String,
    pub degraded_code: Option<String>,
    pub revalidation_command: String,
    pub captured_at_commit: Option<String>,
    pub current_commit: Option<String>,
    pub commit_distance: Option<u32>,
    pub changed_regions: Vec<String>,
    pub anchors: Vec<PackFreshnessAnchorFacet>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackFreshnessAnchorFacet {
    pub anchor_kind: String,
    pub anchor_value_hash: String,
    pub redacted_anchor_value: String,
    pub captured_span_hash: String,
    pub freshness_state: String,
    pub freshness: String,
    pub generation: i64,
    pub stale_anchor: bool,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackItemRedaction {
    pub reason: &'static str,
    pub placeholder: String,
}

impl PackItemRedaction {
    #[must_use]
    pub fn new(reason: &'static str) -> Self {
        Self {
            reason,
            placeholder: crate::policy::redaction_placeholder(reason),
        }
    }
}

impl PackDraftItem {
    #[must_use]
    fn from_selected_candidate(
        rank: u32,
        candidate: PackCandidate,
        redactions: Vec<PackItemRedaction>,
        selected_in: PackSelectionPhase,
    ) -> Self {
        let PackCandidate {
            memory_id,
            section,
            content,
            estimated_tokens,
            relevance,
            utility,
            proximity_to_seed,
            score_breakdown,
            attempt_family_multiplicity,
            provenance,
            why,
            diversity_key,
            trust,
            tombstoned_at,
            lifecycle,
        } = candidate;
        Self {
            rank,
            memory_id,
            section,
            content,
            estimated_tokens,
            relevance,
            utility,
            proximity_to_seed,
            score_breakdown,
            attempt_family_multiplicity,
            provenance,
            why,
            diversity_key,
            trust,
            redactions,
            tombstoned_at,
            lifecycle,
            freshness_facets: Vec::new(),
            selected_in,
        }
    }

    #[must_use]
    pub fn rendered_provenance(&self) -> Vec<RenderedPackProvenance> {
        self.provenance
            .iter()
            .map(PackProvenance::rendered)
            .collect()
    }
}

fn redact_pack_candidate(candidate: PackCandidate) -> (PackCandidate, Vec<PackItemRedaction>) {
    let PackCandidate {
        memory_id,
        section,
        content,
        estimated_tokens,
        relevance,
        utility,
        proximity_to_seed,
        score_breakdown,
        attempt_family_multiplicity,
        provenance,
        why,
        diversity_key,
        trust,
        tombstoned_at,
        lifecycle,
    } = candidate;
    let (content, redactions) = redact_pack_item_content(content);
    let estimated_tokens = if redactions.is_empty() {
        estimated_tokens
    } else {
        estimate_tokens_default(&content).max(1)
    };
    (
        PackCandidate {
            memory_id,
            section,
            content,
            estimated_tokens,
            relevance,
            utility,
            proximity_to_seed,
            score_breakdown,
            attempt_family_multiplicity,
            provenance,
            why,
            diversity_key,
            trust,
            tombstoned_at,
            lifecycle,
        },
        redactions,
    )
}

fn redact_pack_item_content(content: String) -> (String, Vec<PackItemRedaction>) {
    let report = crate::policy::redact_secret_like_content(&content);
    if !report.redacted {
        return (report.content, Vec::new());
    }
    let redactions = report
        .redacted_reasons
        .into_iter()
        .map(PackItemRedaction::new)
        .collect();
    (report.content, redactions)
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackOmission {
    pub memory_id: MemoryId,
    pub estimated_tokens: u32,
    pub relevance: UnitScore,
    pub utility: UnitScore,
    pub attempt_family_multiplicity: Option<PackAttemptFamilyMultiplicitySnapshot>,
    pub reason: PackOmissionReason,
    pub rejected_at: PackRejectionStage,
    pub feasible: bool,
    pub could_fit_with_budget: Option<u32>,
}

impl PackOmission {
    fn from_candidate(
        candidate: &PackCandidate,
        reason: PackOmissionReason,
        could_fit_with_budget: Option<u32>,
    ) -> Self {
        Self::from_candidate_at(
            candidate,
            reason,
            PackRejectionStage::Selection,
            could_fit_with_budget,
        )
    }

    fn from_candidate_at(
        candidate: &PackCandidate,
        reason: PackOmissionReason,
        rejected_at: PackRejectionStage,
        could_fit_with_budget: Option<u32>,
    ) -> Self {
        Self {
            memory_id: candidate.memory_id,
            estimated_tokens: candidate.estimated_tokens,
            relevance: candidate.relevance,
            utility: candidate.utility,
            attempt_family_multiplicity: candidate.attempt_family_multiplicity.clone(),
            reason,
            rejected_at,
            feasible: false,
            could_fit_with_budget,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackOmissionReason {
    TokenBudgetExceeded,
    RedundantCandidate,
    BelowRelevanceFloor,
    ExcludedByPolicy,
    ExcludedByFilter,
    /// bd-1n0np.7.5 — dropped by the pack-time contradiction guard: the
    /// lower-standing side of an unresolved hard contradiction.
    ContradictionSuppressed,
}

impl PackOmissionReason {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::TokenBudgetExceeded => "token_budget_exceeded",
            Self::RedundantCandidate => "redundant_candidate",
            Self::BelowRelevanceFloor => "below_relevance_floor",
            Self::ExcludedByPolicy => "excluded_by_policy",
            Self::ExcludedByFilter => "excluded_by_filter",
            Self::ContradictionSuppressed => "contradiction_suppressed",
        }
    }
}

impl fmt::Display for PackOmissionReason {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackRejectionStage {
    CandidateFilter,
    Selection,
}

impl PackRejectionStage {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::CandidateFilter => "candidate_filter",
            Self::Selection => "selection",
        }
    }
}

impl fmt::Display for PackRejectionStage {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

fn compare_omissions_for_output(left: &PackOmission, right: &PackOmission) -> Ordering {
    let left_score = left.relevance.into_inner() + left.utility.into_inner();
    let right_score = right.relevance.into_inner() + right.utility.into_inner();
    // `total_cmp` over `partial_cmp(...).unwrap_or(Equal)`: `UnitScore`
    // validates its inner f32 at construction time (finite, in [0, 1] — see
    // `src/models/memory.rs::UnitScore::parse` at line ~378), so the sum
    // here is always finite in [0, 2] and `partial_cmp` always returns
    // `Some(Ordering)` today. The `unwrap_or(Equal)` is unreachable. But
    // the pack omissions list feeds `ee context "<task>"` / `ee pack "<task>"`
    // — a determinism-contract surface where "same DB + indexes + config +
    // query → byte-identical JSON output" (per AGENTS.md). If a future
    // `PackOmission` constructor bypasses `UnitScore::parse` (e.g. via
    // `transmute`-shaped fixtures or a `#[cfg(test)]` raw-construction
    // path), a NaN that reaches this sort under `partial_cmp(...).unwrap_or(Equal)`
    // would collapse the ordering into intransitivity and silently scramble
    // the `omitted[]` order on the pack JSON output. Defense-in-depth pattern
    // shipped in 96505dc7 (memory.rs dedupe), 9b83f9a9 (insights
    // proximityHotspots), 4a067ecb (insights causalBottlenecks + hits),
    // 23719e1e (graph loadBearing), 18f20375 (influence.rs), and 2eab2028
    // (focus_suggest.rs).
    right_score
        .total_cmp(&left_score)
        .then_with(|| left.memory_id.cmp(&right.memory_id))
}

fn minimal_budget_for_candidate(
    profile: ContextPackProfile,
    used_tokens: u32,
    section_used: u32,
    section: PackSection,
    candidate_tokens: u32,
) -> u32 {
    let required_total_budget = used_tokens.saturating_add(candidate_tokens);
    let required_section_budget = minimal_budget_for_section(
        profile,
        section,
        section_used.saturating_add(candidate_tokens),
    );
    required_total_budget.max(required_section_budget)
}

fn minimal_budget_for_section(
    profile: ContextPackProfile,
    section: PackSection,
    required_tokens: u32,
) -> u32 {
    if required_tokens == 0 {
        return 0;
    }
    let section_mix = ContextProfile::builtin(profile).section_mix;
    let basis_points = section_mix.weight_bps(context_profile_section(section));
    if basis_points == 0 {
        return u32::MAX;
    }

    let mut low = 0_u32;
    let mut high = ((u64::from(required_tokens) * 10_000).div_ceil(u64::from(basis_points)))
        .min(u64::from(u32::MAX)) as u32;
    while low < high {
        let mid = low + ((high - low) / 2);
        let quota = SectionQuotas::for_profile(profile, mid).get(section);
        if quota.max_tokens >= required_tokens {
            high = mid;
        } else {
            low = mid.saturating_add(1);
        }
    }
    low
}

const fn context_profile_section(section: PackSection) -> ContextProfileSection {
    match section {
        PackSection::ProceduralRules => ContextProfileSection::ProceduralRules,
        PackSection::Decisions => ContextProfileSection::Decisions,
        PackSection::Failures => ContextProfileSection::Failures,
        PackSection::Evidence => ContextProfileSection::Evidence,
        PackSection::Artifacts => ContextProfileSection::Artifacts,
    }
}

fn advisory_summary(
    status: PackAdvisoryStatus,
    counts: &PackTrustCounts,
    degraded: &[ContextResponseDegradation],
) -> String {
    match status {
        PackAdvisoryStatus::Clear => {
            "Packed memories are from high-trust classes; still verify provenance before acting."
                .to_string()
        }
        PackAdvisoryStatus::Advisory => {
            let total = counts.advisory().saturating_add(counts.legacy());
            format!(
                "Context includes {} advisory and {} legacy memor{}; treat non-authoritative entries as evidence, not instructions.",
                counts.advisory(),
                counts.legacy(),
                plural_suffix(total, "y", "ies")
            )
        }
        PackAdvisoryStatus::Degraded => {
            let degradation_count = degraded.len();
            if degraded
                .iter()
                .any(|entry| entry.code == "embed_model_unavailable")
            {
                return format!(
                    "Context includes {} degraded signal{}; semantic embedding is unavailable, so treat retrieval ranking as lexical-only until a semantic model is available.",
                    degradation_count,
                    plural_s(degradation_count)
                );
            }
            format!(
                "Context includes {} degraded signal{}; validate advisory memory and repair degraded sources before relying on this pack.",
                degradation_count,
                plural_s(degradation_count)
            )
        }
    }
}

fn memory_ids_for_posture(pack: &PackDraft, posture: PackTrustPosture) -> Vec<String> {
    let mut ids = BTreeSet::new();
    for item in &pack.items {
        if item.trust.posture() == posture {
            ids.insert(item.memory_id.to_string());
        }
    }
    ids.into_iter().collect()
}

const fn plural_s(count: usize) -> &'static str {
    if count == 1 { "" } else { "s" }
}

const fn plural_suffix(count: usize, singular: &'static str, plural: &'static str) -> &'static str {
    if count == 1 { singular } else { plural }
}

fn rendered_provenance_label(uri: &ProvenanceUri) -> (String, Option<String>) {
    match uri {
        ProvenanceUri::CassSession { session, span } => {
            let locator = span.map(line_span_locator);
            let label = match locator.as_deref() {
                Some(locator) => format!("cass-session {session}#{locator}"),
                None => format!("cass-session {session}"),
            };
            (label, locator)
        }
        ProvenanceUri::File { path, span } => {
            let locator = span.map(line_span_locator);
            let label = match locator.as_deref() {
                Some(locator) => format!("{path}:{locator}"),
                None => path.clone(),
            };
            (label, locator)
        }
        ProvenanceUri::EeMemory(id) => (format!("memory {id}"), None),
        ProvenanceUri::Web { url } => (url.clone(), None),
        ProvenanceUri::AgentMail { thread, message } => {
            let locator = message.clone();
            let label = match message {
                Some(message) => format!("agent-mail {thread}/{message}"),
                None => format!("agent-mail {thread}"),
            };
            (label, locator)
        }
        ProvenanceUri::External { scheme, body } => (format!("{scheme}://{body}"), None),
    }
}

fn line_span_locator(span: crate::models::LineSpan) -> String {
    match span.end {
        Some(end) if end != span.start => format!("L{}-{}", span.start, end),
        _ => format!("L{}", span.start),
    }
}

fn source_index(index: usize) -> u32 {
    u32::try_from(index.saturating_add(1)).unwrap_or(u32::MAX)
}

fn token_ratio(numerator: u32, denominator: u32) -> f32 {
    if denominator == 0 {
        0.0
    } else {
        numerator as f32 / denominator as f32
    }
}

fn count_ratio(numerator: usize, denominator: usize) -> f32 {
    if denominator == 0 {
        0.0
    } else {
        numerator as f32 / denominator as f32
    }
}

fn average_metric(sum: f32, count: usize) -> f32 {
    if count == 0 { 0.0 } else { sum / count as f32 }
}

/// Assemble a deterministic context-pack draft from validated candidates.
///
/// Selection uses deterministic MMR-style redundancy control: the first
/// item follows the stable relevance/utility order, then later candidates
/// are penalized when they overlap selected memories by memory id, explicit
/// diversity key, or exact normalized content. Redundant candidates are
/// omitted even when the token budget has room.
///
/// # Errors
///
/// Returns [`PackValidationError::EmptyQuery`] if `query` is empty after
/// trimming.
pub fn assemble_draft(
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
) -> Result<PackDraft, PackValidationError> {
    assemble_draft_with_profile(ContextPackProfile::Balanced, query, budget, candidates)
}

/// Assemble a deterministic context-pack draft using the objective implied
/// by the request profile.
///
/// The default profiles keep the existing MMR-style redundancy objective.
/// The `submodular` profile switches to a deterministic facility-location
/// greedy objective and records the same audit shape for inspection.
///
/// # Errors
///
/// Returns [`PackValidationError::EmptyQuery`] if `query` is empty after
/// trimming.
pub fn assemble_draft_with_profile(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
) -> Result<PackDraft, PackValidationError> {
    assemble_draft_with_profile_and_options(
        profile,
        query,
        budget,
        candidates,
        PackAssemblyOptions::default(),
    )
}

pub fn assemble_draft_with_profile_and_options(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
) -> Result<PackDraft, PackValidationError> {
    let determinism = Deterministic::from_seed(0);
    assemble_draft_with_profile_and_options_seeded(
        profile,
        query,
        budget,
        candidates,
        options,
        &determinism,
    )
}

pub fn assemble_draft_with_profile_and_options_seeded(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
    determinism: &Deterministic<Seed>,
) -> Result<PackDraft, PackValidationError> {
    assemble_draft_with_profile_and_options_seeded_inner(
        profile,
        query,
        budget,
        candidates,
        options,
        determinism,
        None,
    )
}

pub fn assemble_draft_with_profile_and_options_seeded_in_workspace(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
    determinism: &Deterministic<Seed>,
    workspace: &mut PackArenaWorkspace,
) -> Result<PackDraft, PackValidationError> {
    let query = query.into();
    let candidates = candidates.into_iter().collect::<Vec<_>>();
    let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        assemble_draft_with_profile_and_options_seeded_inner(
            profile,
            query,
            budget,
            candidates,
            options,
            determinism,
            Some(workspace),
        )
    }));
    match outcome {
        Ok(result) => result,
        Err(payload) => {
            workspace.poison("panic");
            std::panic::resume_unwind(payload);
        }
    }
}

fn assemble_draft_with_profile_and_options_seeded_inner(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    mut options: PackAssemblyOptions,
    determinism: &Deterministic<Seed>,
    mut workspace: Option<&mut PackArenaWorkspace>,
) -> Result<PackDraft, PackValidationError> {
    // bd-1prrl.7.3: open the arena scope before assembly so the
    // RAII guard's drop runs before the returned `PackDraft` is
    // observed by callers. Workspace reuse requires an explicit
    // PackArenaWorkspace; ordinary calls degrade to disabled allocation
    // instead of stashing scratch in process-global state.
    if options.arena_mode == ArenaMode::WorkspaceReuse && workspace.is_none() {
        tracing::debug!(
            target: "ee::pack::arena",
            arena_mode = ArenaMode::WorkspaceReuse.as_str(),
            arena_policy_version = ARENA_POLICY_VERSION,
            event = "workspace_reuse_without_workspace",
            "workspace_reuse requested without PackArenaWorkspace; falling back to disabled"
        );
        options.arena_mode = ArenaMode::Disabled;
    }
    let reuse_generation = workspace.as_ref().and_then(|arena| {
        (options.arena_mode == ArenaMode::WorkspaceReuse).then(|| arena.generation_key())
    });
    let _arena_scope = ArenaScope::new(options.arena_mode, reuse_generation);
    match profile {
        ContextPackProfile::Submodular => {
            tracing::info!(
                target: "ee::pack::submodular",
                algorithm_id = "deterministic_greedy_facility_location_gain_per_token",
                objective = "facility_location",
                profile = profile.as_str(),
                arena_mode = options.arena_mode.as_str(),
                arena_policy_version = ARENA_POLICY_VERSION,
                "starting pack assembly"
            );
            match workspace.as_deref_mut() {
                Some(arena) if options.arena_mode == ArenaMode::WorkspaceReuse => {
                    assemble_facility_location_draft_reusing_workspace(
                        profile, query, budget, candidates, options, arena,
                    )
                }
                _ => assemble_facility_location_draft(profile, query, budget, candidates, options),
            }
        }
        ContextPackProfile::Compact
        | ContextPackProfile::Balanced
        | ContextPackProfile::Grounding
        | ContextPackProfile::Orientation
        | ContextPackProfile::Thorough => {
            tracing::info!(
                target: "ee::pack::submodular",
                algorithm_id = "mmr_with_coverage_fill_v1",
                objective = "mmr_redundancy",
                profile = profile.as_str(),
                arena_mode = options.arena_mode.as_str(),
                arena_policy_version = ARENA_POLICY_VERSION,
                "starting pack assembly"
            );
            match workspace.as_deref_mut() {
                Some(arena) if options.arena_mode == ArenaMode::WorkspaceReuse => {
                    assemble_mmr_draft_reusing_workspace(
                        profile,
                        query,
                        budget,
                        candidates,
                        options,
                        determinism,
                        arena,
                    )
                }
                _ => assemble_mmr_draft(profile, query, budget, candidates, options, determinism),
            }
        }
    }
}

#[derive(Debug)]
struct PackDraftScratch {
    items: Vec<PackDraftItem>,
    omitted: Vec<PackOmission>,
    steps: Vec<PackSelectionStep>,
}

impl PackDraftScratch {
    fn with_candidate_capacity(candidate_count: usize) -> Self {
        Self {
            items: Vec::with_capacity(candidate_count),
            omitted: Vec::with_capacity(candidate_count),
            steps: Vec::with_capacity(candidate_count),
        }
    }

    fn reset_for_candidate_capacity(&mut self, candidate_count: usize) {
        self.items.clear();
        self.omitted.clear();
        self.steps.clear();
        ensure_vec_capacity(&mut self.items, candidate_count);
        ensure_vec_capacity(&mut self.omitted, candidate_count);
        ensure_vec_capacity(&mut self.steps, candidate_count);
    }
}

#[derive(Debug)]
struct MmrAssemblyScratch {
    draft: PackDraftScratch,
    selected_signatures: Vec<CandidateSignature>,
    coverage_fill_candidates: Vec<MmrCandidate>,
    max_selected_similarities: Vec<f32>,
}

impl MmrAssemblyScratch {
    fn with_candidate_capacity(candidate_count: usize) -> Self {
        let mut max_selected_similarities = Vec::with_capacity(candidate_count);
        max_selected_similarities.resize(candidate_count, 0.0);
        Self {
            draft: PackDraftScratch::with_candidate_capacity(candidate_count),
            selected_signatures: Vec::with_capacity(candidate_count),
            coverage_fill_candidates: Vec::with_capacity(candidate_count),
            max_selected_similarities,
        }
    }

    fn reset_for_candidate_capacity(&mut self, candidate_count: usize) {
        self.draft.reset_for_candidate_capacity(candidate_count);
        self.selected_signatures.clear();
        self.coverage_fill_candidates.clear();
        self.max_selected_similarities.clear();
        ensure_vec_capacity(&mut self.selected_signatures, candidate_count);
        ensure_vec_capacity(&mut self.coverage_fill_candidates, candidate_count);
        ensure_vec_capacity(&mut self.max_selected_similarities, candidate_count);
        self.max_selected_similarities.resize(candidate_count, 0.0);
    }
}

fn ensure_vec_capacity<T>(values: &mut Vec<T>, candidate_count: usize) {
    if values.capacity() < candidate_count {
        let additional = candidate_count.saturating_sub(values.len());
        values.reserve(additional);
    }
}

fn assemble_mmr_draft(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
    determinism: &Deterministic<Seed>,
) -> Result<PackDraft, PackValidationError> {
    let mmr_seed = determinism.shared_child("pack.mmr_tiebreak");
    tracing::debug!(
        target: "ee::pack::determinism",
        seed_scope = %mmr_seed.scope(),
        seed_hash = %mmr_seed.seed_hash_prefix(),
        "threaded deterministic token through MMR pack assembly"
    );

    let query = trim_required(query.into(), PackValidationError::EmptyQuery)?;
    let mut candidates: Vec<MmrCandidate> = candidates
        .into_iter()
        .map(|candidate| MmrCandidate::from_candidate(candidate, options.output_redaction_enabled))
        .collect();
    let candidate_count = candidates.len();
    candidates.sort_by(|left, right| compare_candidates(&left.candidate, &right.candidate));

    let quotas = SectionQuotas::for_profile(profile, budget.max_tokens());

    let mut used_tokens = 0_u32;
    let mut section_usage = SectionTokenUsage::default();
    let mut lod_usage = PackLodBudgetState::from_options(options, budget);
    let mut next_rank = 1_u32;
    let mut scratch = MmrAssemblyScratch::with_candidate_capacity(candidate_count);
    let mut selected_memory_ids = BTreeSet::new();
    let mut objective_value = 0.0_f32;

    if options.include_anti_pattern_first
        && let Some(candidate_index) = anti_pattern_first_mmr_candidate_index(
            &candidates,
            &scratch.max_selected_similarities,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
    {
        let selected_max_similarity = scratch
            .max_selected_similarities
            .swap_remove(candidate_index);
        let selection = candidates.swap_remove(candidate_index);
        let marginal_gain =
            strict_mmr_marginal_gain_from_similarity(&selection, selected_max_similarity);
        let section_used = section_usage.tokens_for(selection.candidate.section);

        if let Some(plan) = pack_lod_candidate_plan(
            &selection.candidate,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) {
            let PackLodCandidatePlan { tier, candidate } = plan;
            let candidate = mark_anti_pattern_first_candidate(candidate);
            match used_tokens.checked_add(candidate.estimated_tokens) {
                Some(total) => {
                    let rank = next_rank;
                    next_rank = next_rank
                        .checked_add(1)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    objective_value += marginal_gain.max(0.0);
                    scratch.draft.steps.push(PackSelectionStep {
                        rank,
                        memory_id: candidate.memory_id,
                        marginal_gain,
                        objective_value,
                        token_cost: candidate.estimated_tokens,
                        feasible: true,
                        covered_features: certificate_features(&candidate),
                    });
                    tracing::debug!(
                        target: "ee::pack::anti_pattern_first",
                        profile = profile.as_str(),
                        phase = PackSelectionPhase::AntiPatternFirst.as_str(),
                        memory_id = %candidate.memory_id,
                        tokens = candidate.estimated_tokens,
                        rank,
                        "selected reserved anti-pattern/failure/risk pack item"
                    );
                    used_tokens = total;
                    let redactions = selection.redactions;
                    section_usage.add_candidate(&candidate);
                    lod_usage.add(tier, candidate.estimated_tokens);
                    selected_memory_ids.insert(candidate.memory_id);
                    let selected_signature = selection.signature.clone();
                    scratch.selected_signatures.push(selection.signature);
                    update_mmr_max_similarities(
                        &mut scratch.max_selected_similarities,
                        &candidates,
                        &selected_signature,
                    );
                    scratch
                        .draft
                        .items
                        .push(PackDraftItem::from_selected_candidate(
                            rank,
                            candidate,
                            redactions,
                            PackSelectionPhase::AntiPatternFirst,
                        ));
                }
                None => {
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_used,
                            selection.candidate.section,
                            selection.candidate.estimated_tokens,
                        )),
                    ));
                }
            }
        }
    }

    while !candidates.is_empty() {
        let candidate_index =
            select_next_candidate_index(&candidates, &scratch.max_selected_similarities);
        // bd-1igvf: swap_remove is O(1) where Vec::remove is O(n); selection order
        // is determined by score with a memory_id tiebreaker in
        // [`select_next_candidate_index`], so vec position does not influence which
        // candidate is picked next, and the parallel relationship between
        // candidates[i] and max_selected_similarities[i] is preserved by matching
        // swap_remove on both.
        let selected_max_similarity = scratch
            .max_selected_similarities
            .swap_remove(candidate_index);
        let selection = candidates.swap_remove(candidate_index);
        let marginal_gain =
            strict_mmr_marginal_gain_from_similarity(&selection, selected_max_similarity);
        if marginal_gain <= 0.0 {
            scratch.coverage_fill_candidates.push(selection);
            continue;
        }

        let section_used = section_usage.tokens_for(selection.candidate.section);

        if let Some(plan) = pack_lod_candidate_plan(
            &selection.candidate,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) {
            let PackLodCandidatePlan { tier, candidate } = plan;
            match used_tokens.checked_add(candidate.estimated_tokens) {
                Some(total) => {
                    let rank = next_rank;
                    next_rank = next_rank
                        .checked_add(1)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    objective_value += marginal_gain.max(0.0);
                    scratch.draft.steps.push(PackSelectionStep {
                        rank,
                        memory_id: candidate.memory_id,
                        marginal_gain,
                        objective_value,
                        token_cost: candidate.estimated_tokens,
                        feasible: true,
                        covered_features: certificate_features(&candidate),
                    });
                    used_tokens = total;
                    let redactions = selection.redactions;
                    section_usage.add_candidate(&candidate);
                    lod_usage.add(tier, candidate.estimated_tokens);
                    selected_memory_ids.insert(candidate.memory_id);
                    let selected_signature = selection.signature.clone();
                    scratch.selected_signatures.push(selection.signature);
                    update_mmr_max_similarities(
                        &mut scratch.max_selected_similarities,
                        &candidates,
                        &selected_signature,
                    );
                    scratch
                        .draft
                        .items
                        .push(PackDraftItem::from_selected_candidate(
                            rank,
                            candidate,
                            redactions,
                            PackSelectionPhase::StrictMmr,
                        ));
                }
                None => {
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_used,
                            selection.candidate.section,
                            selection.candidate.estimated_tokens,
                        )),
                    ));
                }
            }
        } else {
            scratch.draft.omitted.push(PackOmission::from_candidate(
                &selection.candidate,
                PackOmissionReason::TokenBudgetExceeded,
                Some(minimal_budget_for_candidate(
                    profile,
                    used_tokens,
                    section_used,
                    selection.candidate.section,
                    selection.candidate.estimated_tokens,
                )),
            ));
        }
    }

    if options.include_coverage_fill {
        scratch
            .coverage_fill_candidates
            .sort_by(|left, right| compare_candidates(&left.candidate, &right.candidate));
        let coverage_fill_limit = scratch.draft.items.len();
        let mut coverage_fill_count = 0_usize;
        let coverage_fill_candidates = std::mem::take(&mut scratch.coverage_fill_candidates);
        for selection in coverage_fill_candidates {
            if selected_memory_ids.contains(&selection.candidate.memory_id) {
                scratch.draft.omitted.push(PackOmission::from_candidate(
                    &selection.candidate,
                    PackOmissionReason::RedundantCandidate,
                    None,
                ));
                continue;
            }
            if selection.candidate.relevance.into_inner() < DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR {
                scratch.draft.omitted.push(PackOmission::from_candidate_at(
                    &selection.candidate,
                    PackOmissionReason::BelowRelevanceFloor,
                    PackRejectionStage::CandidateFilter,
                    None,
                ));
                continue;
            }
            if coverage_fill_count >= coverage_fill_limit {
                // bd-26k9t: `coverage_fill_limit = items.len()` is set
                // before the loop. When the MMR phase selected zero
                // items, this limit is 0 and every coverage-fill
                // candidate trips this branch — but `RedundantCandidate`
                // is the wrong rationale because there's nothing for
                // them to be redundant *with*. They were squeezed out
                // by the prior phase's budget posture; the honest
                // omission reason is `TokenBudgetExceeded` with the
                // minimal-budget hint, matching the upstream
                // `facility_candidate_is_feasible` rejection path.
                if coverage_fill_limit == 0 {
                    let section_used = section_usage.tokens_for(selection.candidate.section);
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_used,
                            selection.candidate.section,
                            selection.candidate.estimated_tokens,
                        )),
                    ));
                } else {
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::RedundantCandidate,
                        None,
                    ));
                }
                continue;
            }

            let section_used = section_usage.tokens_for(selection.candidate.section);
            if let Some(plan) = pack_lod_candidate_plan(
                &selection.candidate,
                used_tokens,
                budget,
                &quotas,
                &section_usage,
                &lod_usage,
            ) {
                let PackLodCandidatePlan { tier, candidate } = plan;
                match used_tokens.checked_add(candidate.estimated_tokens) {
                    Some(total) => {
                        let rank = next_rank;
                        next_rank = next_rank
                            .checked_add(1)
                            .ok_or(PackValidationError::CandidateRankOverflow)?;
                        let marginal_gain =
                            strict_mmr_marginal_gain(&selection, &scratch.selected_signatures);
                        scratch.draft.steps.push(PackSelectionStep {
                            rank,
                            memory_id: candidate.memory_id,
                            marginal_gain,
                            objective_value,
                            token_cost: candidate.estimated_tokens,
                            feasible: true,
                            covered_features: certificate_features(&candidate),
                        });
                        used_tokens = total;
                        let redactions = selection.redactions;
                        section_usage.add_candidate(&candidate);
                        lod_usage.add(tier, candidate.estimated_tokens);
                        selected_memory_ids.insert(candidate.memory_id);
                        scratch.selected_signatures.push(selection.signature);
                        coverage_fill_count = coverage_fill_count.saturating_add(1);
                        scratch
                            .draft
                            .items
                            .push(PackDraftItem::from_selected_candidate(
                                rank,
                                candidate,
                                redactions,
                                PackSelectionPhase::CoverageFill,
                            ));
                    }
                    None => {
                        scratch.draft.omitted.push(PackOmission::from_candidate(
                            &selection.candidate,
                            PackOmissionReason::TokenBudgetExceeded,
                            Some(minimal_budget_for_candidate(
                                profile,
                                used_tokens,
                                section_used,
                                selection.candidate.section,
                                selection.candidate.estimated_tokens,
                            )),
                        ));
                    }
                }
            } else {
                scratch.draft.omitted.push(PackOmission::from_candidate(
                    &selection.candidate,
                    PackOmissionReason::TokenBudgetExceeded,
                    Some(minimal_budget_for_candidate(
                        profile,
                        used_tokens,
                        section_used,
                        selection.candidate.section,
                        selection.candidate.estimated_tokens,
                    )),
                ));
            }
        }
    } else {
        let coverage_fill_candidates = std::mem::take(&mut scratch.coverage_fill_candidates);
        for selection in coverage_fill_candidates {
            scratch.draft.omitted.push(PackOmission::from_candidate(
                &selection.candidate,
                PackOmissionReason::RedundantCandidate,
                None,
            ));
        }
    }

    let PackDraftScratch {
        items,
        omitted,
        steps,
    } = scratch.draft;

    Ok(PackDraft {
        query,
        budget,
        used_tokens,
        evidence_items: Vec::new(),
        selection_audit: PackSelectionAudit {
            profile,
            objective: PackSelectionObjective::MmrRedundancy,
            algorithm_id: "mmr_with_coverage_fill_v1",
            algorithm_description: "Deterministic MMR ranking with coverage-fill for relevant candidates that still fit the token budget.",
            candidate_count,
            selected_count: items.len(),
            omitted_count: omitted.len(),
            budget_limit: budget.max_tokens(),
            budget_used: used_tokens,
            total_objective_value: objective_value,
            monotone: false,
            submodular: false,
            selected_items: selected_items_from_draft_items(&items),
            steps,
        },
        items,
        omitted,
        hash: None,
    })
}

fn assemble_mmr_draft_reusing_workspace(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
    determinism: &Deterministic<Seed>,
    arena: &mut PackArenaWorkspace,
) -> Result<PackDraft, PackValidationError> {
    let query = trim_required(query.into(), PackValidationError::EmptyQuery)?;
    let candidates = candidates.into_iter().collect::<Vec<_>>();
    let candidate_count = candidates.len();
    let Some(mut scratch) = arena.take_mmr_scratch(candidate_count) else {
        let mut fallback_options = options;
        fallback_options.arena_mode = ArenaMode::Disabled;
        return assemble_mmr_draft(
            profile,
            query,
            budget,
            candidates,
            fallback_options,
            determinism,
        );
    };

    let mmr_seed = determinism.shared_child("pack.mmr_tiebreak");
    tracing::debug!(
        target: "ee::pack::determinism",
        seed_scope = %mmr_seed.scope(),
        seed_hash = %mmr_seed.seed_hash_prefix(),
        "threaded deterministic token through MMR pack assembly"
    );

    let mut candidates: Vec<MmrCandidate> = candidates
        .into_iter()
        .map(|candidate| MmrCandidate::from_candidate(candidate, options.output_redaction_enabled))
        .collect();
    candidates.sort_by(|left, right| compare_candidates(&left.candidate, &right.candidate));

    let quotas = SectionQuotas::for_profile(profile, budget.max_tokens());

    let mut used_tokens = 0_u32;
    let mut section_usage = SectionTokenUsage::default();
    let mut lod_usage = PackLodBudgetState::from_options(options, budget);
    let mut next_rank = 1_u32;
    let mut selected_memory_ids = BTreeSet::new();
    let mut objective_value = 0.0_f32;

    if options.include_anti_pattern_first
        && let Some(candidate_index) = anti_pattern_first_mmr_candidate_index(
            &candidates,
            &scratch.max_selected_similarities,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
    {
        let selected_max_similarity = scratch
            .max_selected_similarities
            .swap_remove(candidate_index);
        let selection = candidates.swap_remove(candidate_index);
        let marginal_gain =
            strict_mmr_marginal_gain_from_similarity(&selection, selected_max_similarity);
        let section_used = section_usage.tokens_for(selection.candidate.section);

        if let Some(plan) = pack_lod_candidate_plan(
            &selection.candidate,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) {
            let PackLodCandidatePlan { tier, candidate } = plan;
            let candidate = mark_anti_pattern_first_candidate(candidate);
            match used_tokens.checked_add(candidate.estimated_tokens) {
                Some(total) => {
                    let rank = next_rank;
                    next_rank = next_rank
                        .checked_add(1)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    objective_value += marginal_gain.max(0.0);
                    scratch.draft.steps.push(PackSelectionStep {
                        rank,
                        memory_id: candidate.memory_id,
                        marginal_gain,
                        objective_value,
                        token_cost: candidate.estimated_tokens,
                        feasible: true,
                        covered_features: certificate_features(&candidate),
                    });
                    tracing::debug!(
                        target: "ee::pack::anti_pattern_first",
                        profile = profile.as_str(),
                        phase = PackSelectionPhase::AntiPatternFirst.as_str(),
                        memory_id = %candidate.memory_id,
                        tokens = candidate.estimated_tokens,
                        rank,
                        "selected reserved anti-pattern/failure/risk pack item"
                    );
                    used_tokens = total;
                    let redactions = selection.redactions;
                    section_usage.add_candidate(&candidate);
                    lod_usage.add(tier, candidate.estimated_tokens);
                    selected_memory_ids.insert(candidate.memory_id);
                    let selected_signature = selection.signature.clone();
                    scratch.selected_signatures.push(selection.signature);
                    update_mmr_max_similarities(
                        &mut scratch.max_selected_similarities,
                        &candidates,
                        &selected_signature,
                    );
                    scratch
                        .draft
                        .items
                        .push(PackDraftItem::from_selected_candidate(
                            rank,
                            candidate,
                            redactions,
                            PackSelectionPhase::AntiPatternFirst,
                        ));
                }
                None => {
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_used,
                            selection.candidate.section,
                            selection.candidate.estimated_tokens,
                        )),
                    ));
                }
            }
        }
    }

    while !candidates.is_empty() {
        let candidate_index =
            select_next_candidate_index(&candidates, &scratch.max_selected_similarities);
        let selected_max_similarity = scratch
            .max_selected_similarities
            .swap_remove(candidate_index);
        let selection = candidates.swap_remove(candidate_index);
        let marginal_gain =
            strict_mmr_marginal_gain_from_similarity(&selection, selected_max_similarity);
        if marginal_gain <= 0.0 {
            scratch.coverage_fill_candidates.push(selection);
            continue;
        }

        let section_used = section_usage.tokens_for(selection.candidate.section);

        if let Some(plan) = pack_lod_candidate_plan(
            &selection.candidate,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) {
            let PackLodCandidatePlan { tier, candidate } = plan;
            match used_tokens.checked_add(candidate.estimated_tokens) {
                Some(total) => {
                    let rank = next_rank;
                    next_rank = next_rank
                        .checked_add(1)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    objective_value += marginal_gain.max(0.0);
                    scratch.draft.steps.push(PackSelectionStep {
                        rank,
                        memory_id: candidate.memory_id,
                        marginal_gain,
                        objective_value,
                        token_cost: candidate.estimated_tokens,
                        feasible: true,
                        covered_features: certificate_features(&candidate),
                    });
                    used_tokens = total;
                    let redactions = selection.redactions;
                    section_usage.add_candidate(&candidate);
                    lod_usage.add(tier, candidate.estimated_tokens);
                    selected_memory_ids.insert(candidate.memory_id);
                    let selected_signature = selection.signature.clone();
                    scratch.selected_signatures.push(selection.signature);
                    update_mmr_max_similarities(
                        &mut scratch.max_selected_similarities,
                        &candidates,
                        &selected_signature,
                    );
                    scratch
                        .draft
                        .items
                        .push(PackDraftItem::from_selected_candidate(
                            rank,
                            candidate,
                            redactions,
                            PackSelectionPhase::StrictMmr,
                        ));
                }
                None => {
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_used,
                            selection.candidate.section,
                            selection.candidate.estimated_tokens,
                        )),
                    ));
                }
            }
        } else {
            scratch.draft.omitted.push(PackOmission::from_candidate(
                &selection.candidate,
                PackOmissionReason::TokenBudgetExceeded,
                Some(minimal_budget_for_candidate(
                    profile,
                    used_tokens,
                    section_used,
                    selection.candidate.section,
                    selection.candidate.estimated_tokens,
                )),
            ));
        }
    }

    if options.include_coverage_fill {
        scratch
            .coverage_fill_candidates
            .sort_by(|left, right| compare_candidates(&left.candidate, &right.candidate));
        let coverage_fill_limit = scratch.draft.items.len();
        let mut coverage_fill_count = 0_usize;
        let coverage_fill_candidates = std::mem::take(&mut scratch.coverage_fill_candidates);
        for selection in coverage_fill_candidates {
            if selected_memory_ids.contains(&selection.candidate.memory_id) {
                scratch.draft.omitted.push(PackOmission::from_candidate(
                    &selection.candidate,
                    PackOmissionReason::RedundantCandidate,
                    None,
                ));
                continue;
            }
            if selection.candidate.relevance.into_inner() < DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR {
                scratch.draft.omitted.push(PackOmission::from_candidate_at(
                    &selection.candidate,
                    PackOmissionReason::BelowRelevanceFloor,
                    PackRejectionStage::CandidateFilter,
                    None,
                ));
                continue;
            }
            if coverage_fill_count >= coverage_fill_limit {
                if coverage_fill_limit == 0 {
                    let section_used = section_usage.tokens_for(selection.candidate.section);
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_used,
                            selection.candidate.section,
                            selection.candidate.estimated_tokens,
                        )),
                    ));
                } else {
                    scratch.draft.omitted.push(PackOmission::from_candidate(
                        &selection.candidate,
                        PackOmissionReason::RedundantCandidate,
                        None,
                    ));
                }
                continue;
            }

            let section_used = section_usage.tokens_for(selection.candidate.section);
            if let Some(plan) = pack_lod_candidate_plan(
                &selection.candidate,
                used_tokens,
                budget,
                &quotas,
                &section_usage,
                &lod_usage,
            ) {
                let PackLodCandidatePlan { tier, candidate } = plan;
                match used_tokens.checked_add(candidate.estimated_tokens) {
                    Some(total) => {
                        let rank = next_rank;
                        next_rank = next_rank
                            .checked_add(1)
                            .ok_or(PackValidationError::CandidateRankOverflow)?;
                        let marginal_gain =
                            strict_mmr_marginal_gain(&selection, &scratch.selected_signatures);
                        scratch.draft.steps.push(PackSelectionStep {
                            rank,
                            memory_id: candidate.memory_id,
                            marginal_gain,
                            objective_value,
                            token_cost: candidate.estimated_tokens,
                            feasible: true,
                            covered_features: certificate_features(&candidate),
                        });
                        used_tokens = total;
                        let redactions = selection.redactions;
                        section_usage.add_candidate(&candidate);
                        lod_usage.add(tier, candidate.estimated_tokens);
                        selected_memory_ids.insert(candidate.memory_id);
                        scratch.selected_signatures.push(selection.signature);
                        coverage_fill_count = coverage_fill_count.saturating_add(1);
                        scratch
                            .draft
                            .items
                            .push(PackDraftItem::from_selected_candidate(
                                rank,
                                candidate,
                                redactions,
                                PackSelectionPhase::CoverageFill,
                            ));
                    }
                    None => {
                        scratch.draft.omitted.push(PackOmission::from_candidate(
                            &selection.candidate,
                            PackOmissionReason::TokenBudgetExceeded,
                            Some(minimal_budget_for_candidate(
                                profile,
                                used_tokens,
                                section_used,
                                selection.candidate.section,
                                selection.candidate.estimated_tokens,
                            )),
                        ));
                    }
                }
            } else {
                scratch.draft.omitted.push(PackOmission::from_candidate(
                    &selection.candidate,
                    PackOmissionReason::TokenBudgetExceeded,
                    Some(minimal_budget_for_candidate(
                        profile,
                        used_tokens,
                        section_used,
                        selection.candidate.section,
                        selection.candidate.estimated_tokens,
                    )),
                ));
            }
        }
    } else {
        let coverage_fill_candidates = std::mem::take(&mut scratch.coverage_fill_candidates);
        for selection in coverage_fill_candidates {
            scratch.draft.omitted.push(PackOmission::from_candidate(
                &selection.candidate,
                PackOmissionReason::RedundantCandidate,
                None,
            ));
        }
    }

    let items = scratch.draft.items.clone();
    let omitted = scratch.draft.omitted.clone();
    let steps = scratch.draft.steps.clone();
    let draft = PackDraft {
        query,
        budget,
        used_tokens,
        evidence_items: Vec::new(),
        selection_audit: PackSelectionAudit {
            profile,
            objective: PackSelectionObjective::MmrRedundancy,
            algorithm_id: "mmr_with_coverage_fill_v1",
            algorithm_description: "Deterministic MMR ranking with coverage-fill for relevant candidates that still fit the token budget.",
            candidate_count,
            selected_count: items.len(),
            omitted_count: omitted.len(),
            budget_limit: budget.max_tokens(),
            budget_used: used_tokens,
            total_objective_value: objective_value,
            monotone: false,
            submodular: false,
            selected_items: selected_items_from_draft_items(&items),
            steps,
        },
        items,
        omitted,
        hash: None,
    };
    arena.put_mmr_scratch(scratch, candidate_count);
    Ok(draft)
}

fn assemble_facility_location_draft(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
) -> Result<PackDraft, PackValidationError> {
    let query = trim_required(query.into(), PackValidationError::EmptyQuery)?;
    let mut candidates: Vec<PackCandidate> = candidates.into_iter().collect();
    candidates.sort_by(compare_candidates);
    let mut candidates: Vec<FacilityCandidateProfile> = candidates
        .into_iter()
        .map(|candidate| {
            FacilityCandidateProfile::from_candidate(candidate, options.output_redaction_enabled)
        })
        .collect();
    // bd-30bfs: an `active` bool mask replaces the previous `Vec<usize>` of
    // remaining indices. The mask gives O(1) "is this candidate still in play"
    // checks and O(1) deactivation, where the prior shape needed an O(n)
    // `position()` scan + O(n) `Vec::remove` tail-shift on every selection
    // round. The companion drain at end-of-loop iterates `active.iter()
    // .enumerate()` in ascending profile_index order, matching the order the
    // previous `Vec::remove`-based bookkeeping produced (`Vec::remove` preserves
    // tail order, so the drain saw 0..n in ascending order). Omission order in
    // the resulting `omitted` Vec is therefore bit-stable.
    let mut active: Vec<bool> = vec![true; candidates.len()];
    let mut remaining_count = candidates.len();
    let mut current_coverages = vec![0.0_f32; candidates.len()];
    let similarity_cache = FacilitySimilarityCache::new(&candidates);
    let mut selector =
        FacilitySelectionQueue::new(&candidates, &current_coverages, &similarity_cache);
    let candidate_count = candidates.len();

    let quotas = SectionQuotas::for_profile(profile, budget.max_tokens());

    let mut used_tokens = 0_u32;
    let mut section_usage = SectionTokenUsage::default();
    let mut lod_usage = PackLodBudgetState::from_options(options, budget);
    let mut next_rank = 1_u32;
    let mut scratch = PackDraftScratch::with_candidate_capacity(candidate_count);
    let mut objective_value = 0.0_f32;

    if options.include_anti_pattern_first
        && let Some(profile_index) = anti_pattern_first_facility_candidate_index(
            &candidates,
            &active,
            &current_coverages,
            &similarity_cache,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
    {
        if active.get(profile_index).copied().unwrap_or(false) {
            let marginal_gain = facility_marginal_gain_cached(
                profile_index,
                &candidates,
                &current_coverages,
                &similarity_cache,
            );
            active[profile_index] = false;
            remaining_count = remaining_count.saturating_sub(1);
            if let Some(candidate_profile) = candidates.get_mut(profile_index)
                && let Some(candidate) = candidate_profile.candidate.take()
            {
                let redactions = std::mem::take(&mut candidate_profile.redactions);
                if let Some(plan) = pack_lod_candidate_plan(
                    &candidate,
                    used_tokens,
                    budget,
                    &quotas,
                    &section_usage,
                    &lod_usage,
                ) {
                    let PackLodCandidatePlan { tier, candidate } = plan;
                    let candidate = mark_anti_pattern_first_candidate(candidate);
                    let rank = next_rank;
                    next_rank = next_rank
                        .checked_add(1)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    used_tokens = used_tokens
                        .checked_add(candidate.estimated_tokens)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    section_usage.add_candidate(&candidate);
                    lod_usage.add(tier, candidate.estimated_tokens);
                    objective_value = update_facility_coverages_cached(
                        &candidates,
                        &mut current_coverages,
                        &similarity_cache,
                        profile_index,
                    );
                    selector.advance_round();
                    let covered_features = certificate_features(&candidate);
                    scratch.steps.push(PackSelectionStep {
                        rank,
                        memory_id: candidate.memory_id,
                        marginal_gain,
                        objective_value,
                        token_cost: candidate.estimated_tokens,
                        feasible: true,
                        covered_features,
                    });
                    tracing::debug!(
                        target: "ee::pack::anti_pattern_first",
                        profile = profile.as_str(),
                        phase = PackSelectionPhase::AntiPatternFirst.as_str(),
                        memory_id = %candidate.memory_id,
                        tokens = candidate.estimated_tokens,
                        rank,
                        "selected reserved anti-pattern/failure/risk pack item"
                    );
                    scratch.items.push(PackDraftItem::from_selected_candidate(
                        rank,
                        candidate,
                        redactions,
                        PackSelectionPhase::AntiPatternFirst,
                    ));
                } else {
                    scratch.omitted.push(PackOmission::from_candidate(
                        &candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_usage.tokens_for(candidate.section),
                            candidate.section,
                            candidate.estimated_tokens,
                        )),
                    ));
                }
            }
        }
    }

    while remaining_count > 0 {
        let Some((profile_index, marginal_gain)) = selector.select(
            &candidates,
            &current_coverages,
            &similarity_cache,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) else {
            scratch.omitted.extend(active.iter().enumerate().filter_map(
                |(profile_index, &is_active)| {
                    if !is_active {
                        return None;
                    }
                    let candidate = candidates.get(profile_index)?.candidate.as_ref()?;
                    Some(PackOmission::from_candidate(
                        candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_usage.tokens_for(candidate.section),
                            candidate.section,
                            candidate.estimated_tokens,
                        )),
                    ))
                },
            ));
            break;
        };

        if marginal_gain <= FACILITY_LOCATION_EPSILON {
            scratch.omitted.extend(active.iter().enumerate().filter_map(
                |(profile_index, &is_active)| {
                    if !is_active {
                        return None;
                    }
                    let candidate = candidates.get(profile_index)?.candidate.as_ref()?;
                    Some(PackOmission::from_candidate(
                        candidate,
                        PackOmissionReason::RedundantCandidate,
                        None,
                    ))
                },
            ));
            break;
        }

        if !active.get(profile_index).copied().unwrap_or(false) {
            continue;
        }
        active[profile_index] = false;
        remaining_count = remaining_count.saturating_sub(1);
        let Some(candidate_profile) = candidates.get_mut(profile_index) else {
            continue;
        };
        let Some(candidate) = candidate_profile.candidate.take() else {
            continue;
        };
        let redactions = std::mem::take(&mut candidate_profile.redactions);
        let Some(plan) = pack_lod_candidate_plan(
            &candidate,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) else {
            scratch.omitted.push(PackOmission::from_candidate(
                &candidate,
                PackOmissionReason::TokenBudgetExceeded,
                Some(minimal_budget_for_candidate(
                    profile,
                    used_tokens,
                    section_usage.tokens_for(candidate.section),
                    candidate.section,
                    candidate.estimated_tokens,
                )),
            ));
            continue;
        };
        let PackLodCandidatePlan { tier, candidate } = plan;
        let rank = next_rank;
        next_rank = next_rank
            .checked_add(1)
            .ok_or(PackValidationError::CandidateRankOverflow)?;
        // bd-1f8l8: mirror the MMR path (assemble_mmr_draft) which uses
        // `checked_add` here. `FacilitySelectionQueue::select` already
        // gates by `facility_candidate_is_feasible` against the absolute
        // budget, so a hit on this overflow path means the feasibility
        // pre-check disagreed with the post-selection accounting — that
        // is a programmer error worth surfacing as
        // `CandidateRankOverflow` rather than silently saturating at
        // u32::MAX.
        used_tokens = used_tokens
            .checked_add(candidate.estimated_tokens)
            .ok_or(PackValidationError::CandidateRankOverflow)?;
        section_usage.add_candidate(&candidate);
        lod_usage.add(tier, candidate.estimated_tokens);
        objective_value = update_facility_coverages_cached(
            &candidates,
            &mut current_coverages,
            &similarity_cache,
            profile_index,
        );
        selector.advance_round();
        let covered_features = certificate_features(&candidate);
        scratch.steps.push(PackSelectionStep {
            rank,
            memory_id: candidate.memory_id,
            marginal_gain,
            objective_value,
            token_cost: candidate.estimated_tokens,
            feasible: true,
            covered_features,
        });
        scratch.items.push(PackDraftItem::from_selected_candidate(
            rank,
            candidate,
            redactions,
            PackSelectionPhase::FacilityLocation,
        ));
    }

    let PackDraftScratch {
        items,
        omitted,
        steps,
    } = scratch;

    Ok(PackDraft {
        query,
        budget,
        used_tokens,
        evidence_items: Vec::new(),
        selection_audit: PackSelectionAudit {
            profile,
            objective: PackSelectionObjective::FacilityLocation,
            algorithm_id: "deterministic_greedy_facility_location_gain_per_token",
            algorithm_description: "Deterministic budgeted greedy selection over the facility-location objective.",
            candidate_count,
            selected_count: items.len(),
            omitted_count: omitted.len(),
            budget_limit: budget.max_tokens(),
            budget_used: used_tokens,
            total_objective_value: objective_value,
            monotone: true,
            submodular: true,
            selected_items: selected_items_from_draft_items(&items),
            steps,
        },
        items,
        omitted,
        hash: None,
    })
}

fn assemble_facility_location_draft_reusing_workspace(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    options: PackAssemblyOptions,
    arena: &mut PackArenaWorkspace,
) -> Result<PackDraft, PackValidationError> {
    let query = trim_required(query.into(), PackValidationError::EmptyQuery)?;
    let candidates = candidates.into_iter().collect::<Vec<_>>();
    let candidate_count = candidates.len();
    let Some(mut scratch) = arena.take_facility_scratch(candidate_count) else {
        let mut fallback_options = options;
        fallback_options.arena_mode = ArenaMode::Disabled;
        return assemble_facility_location_draft(
            profile,
            query,
            budget,
            candidates,
            fallback_options,
        );
    };

    let mut candidates: Vec<PackCandidate> = candidates;
    candidates.sort_by(compare_candidates);
    let mut candidates: Vec<FacilityCandidateProfile> = candidates
        .into_iter()
        .map(|candidate| {
            FacilityCandidateProfile::from_candidate(candidate, options.output_redaction_enabled)
        })
        .collect();
    let mut active: Vec<bool> = vec![true; candidates.len()];
    let mut remaining_count = candidates.len();
    let mut current_coverages = vec![0.0_f32; candidates.len()];
    let similarity_cache = FacilitySimilarityCache::new(&candidates);
    let mut selector =
        FacilitySelectionQueue::new(&candidates, &current_coverages, &similarity_cache);

    let quotas = SectionQuotas::for_profile(profile, budget.max_tokens());

    let mut used_tokens = 0_u32;
    let mut section_usage = SectionTokenUsage::default();
    let mut lod_usage = PackLodBudgetState::from_options(options, budget);
    let mut next_rank = 1_u32;
    let mut objective_value = 0.0_f32;

    if options.include_anti_pattern_first
        && let Some(profile_index) = anti_pattern_first_facility_candidate_index(
            &candidates,
            &active,
            &current_coverages,
            &similarity_cache,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
    {
        if active.get(profile_index).copied().unwrap_or(false) {
            let marginal_gain = facility_marginal_gain_cached(
                profile_index,
                &candidates,
                &current_coverages,
                &similarity_cache,
            );
            active[profile_index] = false;
            remaining_count = remaining_count.saturating_sub(1);
            if let Some(candidate_profile) = candidates.get_mut(profile_index)
                && let Some(candidate) = candidate_profile.candidate.take()
            {
                let redactions = std::mem::take(&mut candidate_profile.redactions);
                if let Some(plan) = pack_lod_candidate_plan(
                    &candidate,
                    used_tokens,
                    budget,
                    &quotas,
                    &section_usage,
                    &lod_usage,
                ) {
                    let PackLodCandidatePlan { tier, candidate } = plan;
                    let candidate = mark_anti_pattern_first_candidate(candidate);
                    let rank = next_rank;
                    next_rank = next_rank
                        .checked_add(1)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    used_tokens = used_tokens
                        .checked_add(candidate.estimated_tokens)
                        .ok_or(PackValidationError::CandidateRankOverflow)?;
                    section_usage.add_candidate(&candidate);
                    lod_usage.add(tier, candidate.estimated_tokens);
                    objective_value = update_facility_coverages_cached(
                        &candidates,
                        &mut current_coverages,
                        &similarity_cache,
                        profile_index,
                    );
                    selector.advance_round();
                    let covered_features = certificate_features(&candidate);
                    scratch.steps.push(PackSelectionStep {
                        rank,
                        memory_id: candidate.memory_id,
                        marginal_gain,
                        objective_value,
                        token_cost: candidate.estimated_tokens,
                        feasible: true,
                        covered_features,
                    });
                    tracing::debug!(
                        target: "ee::pack::anti_pattern_first",
                        profile = profile.as_str(),
                        phase = PackSelectionPhase::AntiPatternFirst.as_str(),
                        memory_id = %candidate.memory_id,
                        tokens = candidate.estimated_tokens,
                        rank,
                        "selected reserved anti-pattern/failure/risk pack item"
                    );
                    scratch.items.push(PackDraftItem::from_selected_candidate(
                        rank,
                        candidate,
                        redactions,
                        PackSelectionPhase::AntiPatternFirst,
                    ));
                } else {
                    scratch.omitted.push(PackOmission::from_candidate(
                        &candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_usage.tokens_for(candidate.section),
                            candidate.section,
                            candidate.estimated_tokens,
                        )),
                    ));
                }
            }
        }
    }

    while remaining_count > 0 {
        let Some((profile_index, marginal_gain)) = selector.select(
            &candidates,
            &current_coverages,
            &similarity_cache,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) else {
            scratch.omitted.extend(active.iter().enumerate().filter_map(
                |(profile_index, &is_active)| {
                    if !is_active {
                        return None;
                    }
                    let candidate = candidates.get(profile_index)?.candidate.as_ref()?;
                    Some(PackOmission::from_candidate(
                        candidate,
                        PackOmissionReason::TokenBudgetExceeded,
                        Some(minimal_budget_for_candidate(
                            profile,
                            used_tokens,
                            section_usage.tokens_for(candidate.section),
                            candidate.section,
                            candidate.estimated_tokens,
                        )),
                    ))
                },
            ));
            break;
        };

        if marginal_gain <= FACILITY_LOCATION_EPSILON {
            scratch.omitted.extend(active.iter().enumerate().filter_map(
                |(profile_index, &is_active)| {
                    if !is_active {
                        return None;
                    }
                    let candidate = candidates.get(profile_index)?.candidate.as_ref()?;
                    Some(PackOmission::from_candidate(
                        candidate,
                        PackOmissionReason::RedundantCandidate,
                        None,
                    ))
                },
            ));
            break;
        }

        if !active.get(profile_index).copied().unwrap_or(false) {
            continue;
        }
        active[profile_index] = false;
        remaining_count = remaining_count.saturating_sub(1);
        let Some(candidate_profile) = candidates.get_mut(profile_index) else {
            continue;
        };
        let Some(candidate) = candidate_profile.candidate.take() else {
            continue;
        };
        let redactions = std::mem::take(&mut candidate_profile.redactions);
        let Some(plan) = pack_lod_candidate_plan(
            &candidate,
            used_tokens,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        ) else {
            scratch.omitted.push(PackOmission::from_candidate(
                &candidate,
                PackOmissionReason::TokenBudgetExceeded,
                Some(minimal_budget_for_candidate(
                    profile,
                    used_tokens,
                    section_usage.tokens_for(candidate.section),
                    candidate.section,
                    candidate.estimated_tokens,
                )),
            ));
            continue;
        };
        let PackLodCandidatePlan { tier, candidate } = plan;
        let rank = next_rank;
        next_rank = next_rank
            .checked_add(1)
            .ok_or(PackValidationError::CandidateRankOverflow)?;
        used_tokens = used_tokens
            .checked_add(candidate.estimated_tokens)
            .ok_or(PackValidationError::CandidateRankOverflow)?;
        section_usage.add_candidate(&candidate);
        lod_usage.add(tier, candidate.estimated_tokens);
        objective_value = update_facility_coverages_cached(
            &candidates,
            &mut current_coverages,
            &similarity_cache,
            profile_index,
        );
        selector.advance_round();
        let covered_features = certificate_features(&candidate);
        scratch.steps.push(PackSelectionStep {
            rank,
            memory_id: candidate.memory_id,
            marginal_gain,
            objective_value,
            token_cost: candidate.estimated_tokens,
            feasible: true,
            covered_features,
        });
        scratch.items.push(PackDraftItem::from_selected_candidate(
            rank,
            candidate,
            redactions,
            PackSelectionPhase::FacilityLocation,
        ));
    }

    let items = scratch.items.clone();
    let omitted = scratch.omitted.clone();
    let steps = scratch.steps.clone();
    let draft = PackDraft {
        query,
        budget,
        used_tokens,
        evidence_items: Vec::new(),
        selection_audit: PackSelectionAudit {
            profile,
            objective: PackSelectionObjective::FacilityLocation,
            algorithm_id: "deterministic_greedy_facility_location_gain_per_token",
            algorithm_description: "Deterministic budgeted greedy selection over the facility-location objective.",
            candidate_count,
            selected_count: items.len(),
            omitted_count: omitted.len(),
            budget_limit: budget.max_tokens(),
            budget_used: used_tokens,
            total_objective_value: objective_value,
            monotone: true,
            submodular: true,
            selected_items: selected_items_from_draft_items(&items),
            steps,
        },
        items,
        omitted,
        hash: None,
    };
    arena.put_facility_scratch(scratch, candidate_count);
    Ok(draft)
}

fn selected_items_from_draft_items(items: &[PackDraftItem]) -> Vec<PackSelectedItem> {
    items
        .iter()
        .map(|item| PackSelectedItem {
            rank: item.rank,
            memory_id: item.memory_id,
            token_cost: item.estimated_tokens,
            feasible: true,
        })
        .collect()
}

fn refresh_selection_audit_objective_after_guard(
    audit: &mut PackSelectionAudit,
    items: &[PackDraftItem],
) {
    let selected_phase_by_memory: std::collections::BTreeMap<String, PackSelectionPhase> = items
        .iter()
        .map(|item| (item.memory_id.to_string(), item.selected_in))
        .collect();
    let mut objective_value = 0.0_f32;
    let mut steps = Vec::with_capacity(items.len());
    for mut step in std::mem::take(&mut audit.steps) {
        let Some(selection_phase) = selected_phase_by_memory
            .get(&step.memory_id.to_string())
            .copied()
        else {
            continue;
        };
        if selection_phase_contributes_to_objective(audit.objective, selection_phase) {
            objective_value += step.marginal_gain.max(0.0);
        }
        step.objective_value = objective_value;
        steps.push(step);
    }
    audit.total_objective_value = objective_value;
    audit.steps = steps;
}

const fn selection_phase_contributes_to_objective(
    objective: PackSelectionObjective,
    phase: PackSelectionPhase,
) -> bool {
    match objective {
        PackSelectionObjective::MmrRedundancy => matches!(
            phase,
            PackSelectionPhase::AntiPatternFirst | PackSelectionPhase::StrictMmr
        ),
        PackSelectionObjective::FacilityLocation => {
            matches!(
                phase,
                PackSelectionPhase::AntiPatternFirst | PackSelectionPhase::FacilityLocation
            )
        }
    }
}

fn anti_pattern_first_mmr_candidate_index(
    candidates: &[MmrCandidate],
    max_selected_similarities: &[f32],
    used_tokens: u32,
    budget: TokenBudget,
    quotas: &SectionQuotas,
    section_usage: &SectionTokenUsage,
    lod_usage: &PackLodBudgetState,
) -> Option<usize> {
    debug_assert_eq!(candidates.len(), max_selected_similarities.len());
    let mut best: Option<usize> = None;
    for (candidate_index, selection) in candidates.iter().enumerate() {
        if !is_anti_pattern_first_candidate(&selection.candidate) {
            continue;
        }
        if strict_mmr_marginal_gain_from_similarity(
            selection,
            max_selected_similarities[candidate_index],
        ) <= 0.0
        {
            continue;
        }
        if pack_lod_candidate_plan(
            &selection.candidate,
            used_tokens,
            budget,
            quotas,
            section_usage,
            lod_usage,
        )
        .is_none()
        {
            continue;
        }
        let replaces_best = match best {
            None => true,
            Some(best_index) => {
                compare_candidates(&selection.candidate, &candidates[best_index].candidate)
                    == Ordering::Less
            }
        };
        if replaces_best {
            best = Some(candidate_index);
        }
    }
    best
}

fn anti_pattern_first_facility_candidate_index(
    candidates: &[FacilityCandidateProfile],
    active: &[bool],
    current_coverages: &[f32],
    similarity_cache: &FacilitySimilarityCache,
    used_tokens: u32,
    budget: TokenBudget,
    quotas: &SectionQuotas,
    section_usage: &SectionTokenUsage,
    lod_usage: &PackLodBudgetState,
) -> Option<usize> {
    let mut best: Option<usize> = None;
    for (profile_index, profile) in candidates.iter().enumerate() {
        if !active.get(profile_index).copied().unwrap_or(false) {
            continue;
        }
        let Some(candidate) = profile.candidate.as_ref() else {
            continue;
        };
        if !is_anti_pattern_first_candidate(candidate) {
            continue;
        }
        if facility_marginal_gain_cached(
            profile_index,
            candidates,
            current_coverages,
            similarity_cache,
        ) <= FACILITY_LOCATION_EPSILON
        {
            continue;
        }
        if pack_lod_candidate_plan(
            candidate,
            used_tokens,
            budget,
            quotas,
            section_usage,
            lod_usage,
        )
        .is_none()
        {
            continue;
        }
        let replaces_best = match best {
            None => true,
            Some(best_index) => match candidates[best_index].candidate.as_ref() {
                Some(best_candidate) => {
                    compare_candidates(candidate, best_candidate) == Ordering::Less
                }
                None => true,
            },
        };
        if replaces_best {
            best = Some(profile_index);
        }
    }
    best
}

fn is_anti_pattern_first_candidate(candidate: &PackCandidate) -> bool {
    candidate.section == PackSection::Failures
        && candidate.relevance.into_inner() >= DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR
}

fn mark_anti_pattern_first_candidate(mut candidate: PackCandidate) -> PackCandidate {
    const PREFIX: &str = "What NOT to do: selected from the reserved anti-pattern/failure/risk slice before action. ";
    if !candidate.why.starts_with("What NOT to do:") {
        candidate.why = format!("{PREFIX}{}", candidate.why);
    }
    candidate
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct CandidateSignature {
    memory_id: MemoryId,
    diversity_key: Option<String>,
    normalized_content: String,
    content_terms: Vec<String>,
}

impl From<&PackCandidate> for CandidateSignature {
    fn from(candidate: &PackCandidate) -> Self {
        let normalized_content = normalize_redundancy_content(&candidate.content);
        let content_terms = normalized_terms(&normalized_content);
        Self {
            memory_id: candidate.memory_id,
            diversity_key: candidate.diversity_key.clone(),
            normalized_content,
            content_terms,
        }
    }
}

#[derive(Clone, Debug)]
struct MmrCandidate {
    candidate: PackCandidate,
    signature: CandidateSignature,
    redactions: Vec<PackItemRedaction>,
}

impl MmrCandidate {
    fn from_candidate(candidate: PackCandidate, output_redaction_enabled: bool) -> Self {
        let (candidate, redactions) = if output_redaction_enabled {
            redact_pack_candidate(candidate)
        } else {
            (candidate, Vec::new())
        };
        let signature = CandidateSignature::from(&candidate);
        Self {
            candidate,
            signature,
            redactions,
        }
    }
}

#[derive(Clone, Debug)]
struct FacilityCandidateProfile {
    candidate: Option<PackCandidate>,
    signature: CandidateSignature,
    weight: f32,
    redactions: Vec<PackItemRedaction>,
}

impl From<PackCandidate> for MmrCandidate {
    fn from(candidate: PackCandidate) -> Self {
        Self::from_candidate(candidate, true)
    }
}

impl FacilityCandidateProfile {
    fn from_candidate(candidate: PackCandidate, output_redaction_enabled: bool) -> Self {
        let (candidate, redactions) = if output_redaction_enabled {
            redact_pack_candidate(candidate)
        } else {
            (candidate, Vec::new())
        };
        let signature = CandidateSignature::from(&candidate);
        let weight = facility_candidate_weight(&candidate);
        Self {
            candidate: Some(candidate),
            signature,
            weight,
            redactions,
        }
    }
}

impl From<PackCandidate> for FacilityCandidateProfile {
    fn from(candidate: PackCandidate) -> Self {
        Self::from_candidate(candidate, true)
    }
}

#[derive(Clone, Debug)]
struct FacilityQueueEntry {
    profile_index: usize,
    marginal_gain: f32,
    gain_ratio: f32,
    generation: u32,
}

impl PartialEq for FacilityQueueEntry {
    fn eq(&self, other: &Self) -> bool {
        self.profile_index == other.profile_index
            && self.generation == other.generation
            && self.marginal_gain.total_cmp(&other.marginal_gain) == Ordering::Equal
            && self.gain_ratio.total_cmp(&other.gain_ratio) == Ordering::Equal
    }
}

impl Eq for FacilityQueueEntry {}

impl Ord for FacilityQueueEntry {
    fn cmp(&self, other: &Self) -> Ordering {
        self.gain_ratio
            .total_cmp(&other.gain_ratio)
            .then_with(|| self.marginal_gain.total_cmp(&other.marginal_gain))
            .then_with(|| other.profile_index.cmp(&self.profile_index))
            .then_with(|| self.generation.cmp(&other.generation))
    }
}

impl PartialOrd for FacilityQueueEntry {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

#[derive(Clone, Debug)]
struct FacilitySimilarityCache {
    width: usize,
    values: Vec<f32>,
}

impl FacilitySimilarityCache {
    fn new(universe: &[FacilityCandidateProfile]) -> Self {
        let width = universe.len();
        let mut values = vec![0.0_f32; width.saturating_mul(width)];
        for left_index in 0..width {
            values[left_index * width + left_index] = 1.0;
            for right_index in (left_index + 1)..width {
                let similarity = facility_signature_similarity(
                    &universe[left_index].signature,
                    &universe[right_index].signature,
                );
                values[left_index * width + right_index] = similarity;
                values[right_index * width + left_index] = similarity;
            }
        }
        Self { width, values }
    }

    fn similarity(&self, universe_index: usize, selected_index: usize) -> f32 {
        let Some(offset) = universe_index
            .checked_mul(self.width)
            .and_then(|base| base.checked_add(selected_index))
        else {
            return 0.0;
        };
        self.values.get(offset).copied().unwrap_or(0.0)
    }
}

#[derive(Clone, Debug)]
struct FacilitySelectionQueue {
    heap: BinaryHeap<FacilityQueueEntry>,
    generation: u32,
}

impl FacilitySelectionQueue {
    fn new(
        universe: &[FacilityCandidateProfile],
        current_coverages: &[f32],
        similarity_cache: &FacilitySimilarityCache,
    ) -> Self {
        let mut heap = BinaryHeap::with_capacity(universe.len());
        for profile_index in 0..universe.len() {
            if let Some(entry) = facility_queue_entry(
                profile_index,
                universe,
                current_coverages,
                similarity_cache,
                0,
            ) {
                heap.push(entry);
            }
        }
        Self {
            heap,
            generation: 0,
        }
    }

    fn advance_round(&mut self) {
        self.generation = self.generation.saturating_add(1);
    }

    fn select(
        &mut self,
        universe: &[FacilityCandidateProfile],
        current_coverages: &[f32],
        similarity_cache: &FacilitySimilarityCache,
        used_tokens: u32,
        budget: TokenBudget,
        quotas: &SectionQuotas,
        section_usage: &SectionTokenUsage,
        lod_usage: &PackLodBudgetState,
    ) -> Option<(usize, f32)> {
        if lod_usage.has_compressed_tiers() {
            return select_facility_lod_candidate_index(
                universe,
                current_coverages,
                similarity_cache,
                used_tokens,
                budget,
                quotas,
                section_usage,
                lod_usage,
            );
        }

        while let Some(entry) = self.heap.pop() {
            let profile_index = entry.profile_index;
            let Some(profile) = universe.get(profile_index) else {
                continue;
            };
            let Some(candidate) = profile.candidate.as_ref() else {
                continue;
            };
            if pack_lod_candidate_plan(
                candidate,
                used_tokens,
                budget,
                quotas,
                section_usage,
                lod_usage,
            )
            .is_none()
            {
                continue;
            }
            if entry.generation == self.generation {
                return Some((profile_index, entry.marginal_gain));
            }
            if let Some(refreshed) = facility_queue_entry(
                profile_index,
                universe,
                current_coverages,
                similarity_cache,
                self.generation,
            ) {
                self.heap.push(refreshed);
            }
        }
        None
    }
}

fn select_next_candidate_index(
    candidates: &[MmrCandidate],
    max_selected_similarities: &[f32],
) -> usize {
    debug_assert_eq!(candidates.len(), max_selected_similarities.len());
    let mut best_index = 0_usize;
    let mut best_score =
        strict_mmr_marginal_gain_from_similarity(&candidates[0], max_selected_similarities[0]);
    for (candidate_index, candidate) in candidates.iter().enumerate().skip(1) {
        let score = strict_mmr_marginal_gain_from_similarity(
            candidate,
            max_selected_similarities[candidate_index],
        );
        let ordering = best_score.total_cmp(&score).then_with(|| {
            compare_candidates(&candidate.candidate, &candidates[best_index].candidate)
        });
        if ordering == Ordering::Less {
            best_index = candidate_index;
            best_score = score;
        }
    }
    best_index
}

fn strict_mmr_marginal_gain(candidate: &MmrCandidate, selected: &[CandidateSignature]) -> f32 {
    let max_similarity = max_selected_similarity(&candidate.signature, selected);
    strict_mmr_marginal_gain_from_similarity(candidate, max_similarity)
}

fn strict_mmr_marginal_gain_from_similarity(candidate: &MmrCandidate, max_similarity: f32) -> f32 {
    if max_similarity >= 1.0 {
        0.0
    } else {
        let relevance_score = candidate.candidate.relevance.into_inner();
        (DEFAULT_MMR_RELEVANCE_WEIGHT * relevance_score)
            - ((1.0 - DEFAULT_MMR_RELEVANCE_WEIGHT) * max_similarity)
    }
}

fn max_selected_similarity(candidate: &CandidateSignature, selected: &[CandidateSignature]) -> f32 {
    selected
        .iter()
        .map(|signature| candidate_signature_similarity(candidate, signature))
        .fold(0.0_f32, |a, b| if b.is_nan() { a } else { a.max(b) })
}

fn update_mmr_max_similarities(
    max_selected_similarities: &mut [f32],
    candidates: &[MmrCandidate],
    selected: &CandidateSignature,
) {
    debug_assert_eq!(candidates.len(), max_selected_similarities.len());
    for (max_similarity, candidate) in max_selected_similarities.iter_mut().zip(candidates) {
        let selected_similarity = candidate_signature_similarity(&candidate.signature, selected);
        if !selected_similarity.is_nan() {
            *max_similarity = (*max_similarity).max(selected_similarity);
        }
    }
}

fn facility_queue_entry(
    profile_index: usize,
    universe: &[FacilityCandidateProfile],
    current_coverages: &[f32],
    similarity_cache: &FacilitySimilarityCache,
    generation: u32,
) -> Option<FacilityQueueEntry> {
    let profile = universe.get(profile_index)?;
    let candidate = profile.candidate.as_ref()?;
    if candidate.estimated_tokens == 0 {
        return None;
    }
    let marginal_gain =
        facility_marginal_gain_cached(profile_index, universe, current_coverages, similarity_cache);
    Some(FacilityQueueEntry {
        profile_index,
        marginal_gain,
        gain_ratio: marginal_gain / candidate.estimated_tokens as f32,
        generation,
    })
}

fn select_facility_lod_candidate_index(
    universe: &[FacilityCandidateProfile],
    current_coverages: &[f32],
    similarity_cache: &FacilitySimilarityCache,
    used_tokens: u32,
    budget: TokenBudget,
    quotas: &SectionQuotas,
    section_usage: &SectionTokenUsage,
    lod_usage: &PackLodBudgetState,
) -> Option<(usize, f32)> {
    let mut best: Option<(usize, f32, f32)> = None;
    for (profile_index, profile) in universe.iter().enumerate() {
        let Some(candidate) = profile.candidate.as_ref() else {
            continue;
        };
        // Mirror facility_queue_entry's guard: a zero-token ORIGINAL is a
        // degenerate estimate and must not be resurrected by a >=1-token
        // truncated-preview/link-only plan into an infinite-gain pick.
        if candidate.estimated_tokens == 0 {
            continue;
        }
        let Some(plan) = pack_lod_candidate_plan(
            candidate,
            used_tokens,
            budget,
            quotas,
            section_usage,
            lod_usage,
        ) else {
            continue;
        };
        if plan.candidate.estimated_tokens == 0 {
            continue;
        }
        let marginal_gain = facility_marginal_gain_cached(
            profile_index,
            universe,
            current_coverages,
            similarity_cache,
        );
        let gain_ratio = marginal_gain / plan.candidate.estimated_tokens as f32;
        match best {
            None => best = Some((profile_index, marginal_gain, gain_ratio)),
            Some((best_profile_index, best_marginal_gain, best_gain_ratio)) => {
                if gain_ratio
                    .total_cmp(&best_gain_ratio)
                    .then_with(|| marginal_gain.total_cmp(&best_marginal_gain))
                    .then_with(|| best_profile_index.cmp(&profile_index))
                    == Ordering::Greater
                {
                    best = Some((profile_index, marginal_gain, gain_ratio));
                }
            }
        }
    }
    best.map(|(profile_index, marginal_gain, _)| (profile_index, marginal_gain))
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
struct SectionTokenUsage {
    used: [u32; 5],
}

impl SectionTokenUsage {
    fn tokens_for(self, section: PackSection) -> u32 {
        self.used[section as usize]
    }

    fn add_candidate(&mut self, candidate: &PackCandidate) {
        let used = &mut self.used[candidate.section as usize];
        *used = used.saturating_add(candidate.estimated_tokens);
    }
}

fn lod_share_tokens(max_tokens: u32, basis_points: u16, total_basis_points: u32) -> u32 {
    if basis_points == 0 || max_tokens == 0 || total_basis_points == 0 {
        return 0;
    }
    let tokens = (u64::from(max_tokens) * u64::from(basis_points)) / u64::from(total_basis_points);
    u32::try_from(tokens).unwrap_or(u32::MAX).max(1)
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct PackLodBudgetLimits {
    full: u32,
    truncated_preview: u32,
    link_only: u32,
}

impl PackLodBudgetLimits {
    const fn full_only(max_tokens: u32) -> Self {
        Self {
            full: max_tokens,
            truncated_preview: 0,
            link_only: 0,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum PackLodTier {
    Full,
    TruncatedPreview,
    LinkOnly,
}

impl PackLodTier {
    const fn index(self) -> usize {
        match self {
            Self::Full => 0,
            Self::TruncatedPreview => 1,
            Self::LinkOnly => 2,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct PackLodBudgetState {
    limits: PackLodBudgetLimits,
    used: [u32; 3],
}

impl PackLodBudgetState {
    fn from_options(options: PackAssemblyOptions, budget: TokenBudget) -> Self {
        let limits = options.lod_budget_shares.map_or(
            PackLodBudgetLimits {
                full: budget.max_tokens(),
                truncated_preview: 0,
                link_only: 0,
            },
            |shares| shares.limits(budget),
        );
        Self {
            limits,
            used: [0; 3],
        }
    }

    fn remaining(self, tier: PackLodTier) -> u32 {
        match tier {
            PackLodTier::Full => self.limits.full,
            PackLodTier::TruncatedPreview => self.limits.truncated_preview,
            PackLodTier::LinkOnly => self.limits.link_only,
        }
        .saturating_sub(self.used[tier.index()])
    }

    fn add(&mut self, tier: PackLodTier, tokens: u32) {
        let used = &mut self.used[tier.index()];
        *used = used.saturating_add(tokens);
    }

    fn has_compressed_tiers(self) -> bool {
        self.limits.truncated_preview > 0 || self.limits.link_only > 0
    }
}

#[derive(Clone, Debug, PartialEq)]
struct PackLodCandidatePlan {
    tier: PackLodTier,
    candidate: PackCandidate,
}

fn pack_lod_candidate_plan(
    candidate: &PackCandidate,
    used_tokens: u32,
    budget: TokenBudget,
    quotas: &SectionQuotas,
    section_usage: &SectionTokenUsage,
    lod_usage: &PackLodBudgetState,
) -> Option<PackLodCandidatePlan> {
    for tier in [
        PackLodTier::Full,
        PackLodTier::TruncatedPreview,
        PackLodTier::LinkOnly,
    ] {
        let remaining = lod_usage.remaining(tier);
        if remaining == 0 {
            continue;
        }
        let Some(rendered_candidate) = candidate_for_lod_tier(candidate, tier, remaining) else {
            continue;
        };
        if rendered_candidate.estimated_tokens > remaining {
            continue;
        }
        if facility_candidate_is_feasible(
            &rendered_candidate,
            used_tokens,
            budget,
            quotas,
            section_usage,
        ) {
            return Some(PackLodCandidatePlan {
                tier,
                candidate: rendered_candidate,
            });
        }
    }
    None
}

fn candidate_for_lod_tier(
    candidate: &PackCandidate,
    tier: PackLodTier,
    token_limit: u32,
) -> Option<PackCandidate> {
    match tier {
        PackLodTier::Full => (candidate.estimated_tokens <= token_limit).then(|| candidate.clone()),
        PackLodTier::TruncatedPreview => preview_lod_candidate(candidate, token_limit),
        PackLodTier::LinkOnly => link_only_lod_candidate(candidate, token_limit),
    }
}

fn preview_lod_candidate(candidate: &PackCandidate, token_limit: u32) -> Option<PackCandidate> {
    let content = truncated_preview_content(&candidate.content, token_limit)?;
    let estimated_tokens = estimate_tokens_default(&content).max(1);
    if estimated_tokens > token_limit {
        return None;
    }
    let mut preview = candidate.clone();
    preview.content = content;
    preview.estimated_tokens = estimated_tokens;
    Some(preview)
}

fn truncated_preview_content(content: &str, token_limit: u32) -> Option<String> {
    if token_limit == 0 {
        return None;
    }
    let words = content.split_whitespace().collect::<Vec<_>>();
    if words.is_empty() {
        return None;
    }
    let max_take_count = words.len().checked_sub(1)?;
    for take_count in (1..=max_take_count).rev() {
        let mut preview = words[..take_count].join(" ");
        if take_count < words.len() {
            preview.push_str(" ...");
        }
        if estimate_tokens_default(&preview) <= token_limit {
            return Some(preview);
        }
    }
    None
}

fn link_only_lod_candidate(candidate: &PackCandidate, token_limit: u32) -> Option<PackCandidate> {
    let candidates = [
        Some(format!("Memory {}", candidate.memory_id)),
        Some(candidate.memory_id.to_string()),
    ];
    let content = candidates
        .into_iter()
        .flatten()
        .find(|content| estimate_tokens_default(content) <= token_limit)?;
    let estimated_tokens = estimate_tokens_default(&content).max(1);
    let mut link_only = candidate.clone();
    link_only.content = content;
    link_only.estimated_tokens = estimated_tokens;
    Some(link_only)
}

fn facility_candidate_is_feasible(
    candidate: &PackCandidate,
    used_tokens: u32,
    budget: TokenBudget,
    quotas: &SectionQuotas,
    section_usage: &SectionTokenUsage,
) -> bool {
    if candidate.estimated_tokens == 0 {
        return false;
    }
    let remaining_budget = budget.max_tokens().saturating_sub(used_tokens);
    if candidate.estimated_tokens > remaining_budget {
        return false;
    }
    let section_used = section_usage.tokens_for(candidate.section);
    quotas.has_room(candidate.section, section_used, candidate.estimated_tokens)
}

#[cfg(test)]
fn facility_marginal_gain(
    profile: &FacilityCandidateProfile,
    universe: &[FacilityCandidateProfile],
    current_coverages: &[f32],
) -> f32 {
    #[cfg(test)]
    FACILITY_MARGINAL_GAIN_EVALUATIONS
        .with(|evaluations| evaluations.set(evaluations.get().saturating_add(1)));

    universe
        .iter()
        .zip(current_coverages.iter())
        .map(|(universe_profile, &current_coverage)| {
            let candidate_sim =
                facility_signature_similarity(&universe_profile.signature, &profile.signature);
            let new_coverage = current_coverage.max(candidate_sim);
            let gain = new_coverage - current_coverage;
            universe_profile.weight * gain
        })
        .sum()
}

fn facility_marginal_gain_cached(
    profile_index: usize,
    universe: &[FacilityCandidateProfile],
    current_coverages: &[f32],
    similarity_cache: &FacilitySimilarityCache,
) -> f32 {
    #[cfg(test)]
    FACILITY_MARGINAL_GAIN_EVALUATIONS
        .with(|evaluations| evaluations.set(evaluations.get().saturating_add(1)));

    universe
        .iter()
        .zip(current_coverages.iter())
        .enumerate()
        .map(|(universe_index, (universe_profile, &current_coverage))| {
            // bd-q68j3: swap args from (universe_index, profile_index) to
            // (profile_index, universe_index). similarity_cache is symmetric, so
            // the f32 returned is identical, but the access pattern walks row
            // `profile_index` contiguously (stride 1) instead of striding by
            // `width` down a column. For the 128-candidate benchmark this turns
            // an L1-evicting column walk into a sequential read of one row.
            let candidate_sim = similarity_cache.similarity(profile_index, universe_index);
            let new_coverage = current_coverage.max(candidate_sim);
            let gain = new_coverage - current_coverage;
            universe_profile.weight * gain
        })
        .sum()
}

fn update_facility_coverages_cached(
    universe: &[FacilityCandidateProfile],
    current_coverages: &mut [f32],
    similarity_cache: &FacilitySimilarityCache,
    selected_index: usize,
) -> f32 {
    debug_assert_eq!(universe.len(), current_coverages.len());
    let mut objective_value = 0.0;
    for (universe_index, (universe_profile, current_coverage)) in universe
        .iter()
        .zip(current_coverages.iter_mut())
        .enumerate()
    {
        // bd-q68j3: swap args; symmetric cache makes the f32 identical, but
        // `similarity(selected_index, universe_index)` walks row `selected_index`
        // contiguously instead of striding by `width` down column `selected_index`.
        let selected_coverage = similarity_cache.similarity(selected_index, universe_index);
        *current_coverage = (*current_coverage).max(selected_coverage);
        objective_value += universe_profile.weight * *current_coverage;
    }
    objective_value
}

#[cfg(test)]
pub(crate) fn facility_location_value(
    selected: &[CandidateSignature],
    universe: &[PackCandidate],
) -> f32 {
    if selected.is_empty() {
        return 0.0;
    }
    let universe: Vec<FacilityCandidateProfile> = universe
        .iter()
        .cloned()
        .map(FacilityCandidateProfile::from)
        .collect();
    universe
        .iter()
        .map(|candidate| {
            let coverage = selected
                .iter()
                .map(|signature| facility_signature_similarity(&candidate.signature, signature))
                .fold(0.0_f32, |a, b| if b.is_nan() { a } else { a.max(b) });
            candidate.weight * coverage
        })
        .sum()
}

fn facility_candidate_weight(candidate: &PackCandidate) -> f32 {
    (FACILITY_LOCATION_RELEVANCE_WEIGHT * candidate.relevance.into_inner())
        + (FACILITY_LOCATION_UTILITY_WEIGHT * candidate.utility.into_inner())
}

/// Similarity used by the facility-location picker to decide whether
/// `candidate` is redundant with an already-selected signature.
///
/// Returns `1.0` for an exact memory_id or normalized-content match, then
/// falls back to the larger of:
/// - [`FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR`] when both sides
///   advertise the same `diversity_key` bucket, and
/// - the Jaccard content overlap from precomputed content terms.
///
/// The function intentionally does *not* combine the two signals: matching
/// only the diversity_key is a coarse bucket hint, not evidence of literal
/// duplication, so the Jaccard signal is allowed to override the floor when
/// the texts genuinely overlap.
#[cfg(test)]
fn facility_similarity(candidate: &PackCandidate, selected: &CandidateSignature) -> f32 {
    let candidate = CandidateSignature::from(candidate);
    facility_signature_similarity(&candidate, selected)
}

fn facility_signature_similarity(
    candidate: &CandidateSignature,
    selected: &CandidateSignature,
) -> f32 {
    if candidate.memory_id == selected.memory_id {
        return 1.0;
    }
    if candidate.normalized_content == selected.normalized_content {
        return 1.0;
    }

    let mut similarity = 0.0_f32;
    if let Some(diversity_key) = &candidate.diversity_key
        && selected.diversity_key.as_ref() == Some(diversity_key)
    {
        similarity = similarity.max(FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR);
    }
    similarity.max(content_overlap_similarity_terms(
        &candidate.content_terms,
        &selected.content_terms,
    ))
}

/// Compute the Jaccard similarity (`|A ∩ B| / |A ∪ B|`) between two
/// term lists.
///
/// **Precondition (bd-1t2oz).** Both `left_terms` and `right_terms` MUST
/// be sorted ascending and deduplicated. The intersection step uses a
/// merge-style two-pointer scan that silently undercounts matches if
/// either input is unsorted, and the `|A| + |B| - |intersection|` union
/// formula only equals the true set-union size when both sides are
/// deduped. The only writer in tree (`normalized_terms`) does both
/// (`sort_unstable` + `dedup`) before storing into
/// `CandidateSignature.content_terms`; any future writer must preserve
/// this invariant or the similarity score silently drifts.
fn content_overlap_similarity_terms(left_terms: &[String], right_terms: &[String]) -> f32 {
    debug_assert!(
        is_sorted_and_deduped(left_terms),
        "content_overlap_similarity_terms: left_terms must be sorted+deduped (bd-1t2oz)"
    );
    debug_assert!(
        is_sorted_and_deduped(right_terms),
        "content_overlap_similarity_terms: right_terms must be sorted+deduped (bd-1t2oz)"
    );
    if left_terms.is_empty() || right_terms.is_empty() {
        return 0.0;
    }
    let intersection = sorted_term_intersection_count(left_terms, right_terms);
    let union = left_terms
        .len()
        .saturating_add(right_terms.len())
        .saturating_sub(intersection);
    if union == 0 {
        0.0
    } else {
        intersection as f32 / union as f32
    }
}

/// Sorted+deduped invariant predicate paired with the doc on
/// [`content_overlap_similarity_terms`]. Used inside `debug_assert!` so
/// it has zero release-mode cost.
fn is_sorted_and_deduped(terms: &[String]) -> bool {
    terms.windows(2).all(|pair| pair[0] < pair[1])
}

/// Two-pointer intersection-count over two sorted+deduped term slices.
/// Caller MUST ensure the precondition holds (see
/// [`content_overlap_similarity_terms`] doc / bd-1t2oz); if either
/// input is unsorted the count silently undershoots.
fn sorted_term_intersection_count(left_terms: &[String], right_terms: &[String]) -> usize {
    let mut left_index = 0usize;
    let mut right_index = 0usize;
    let mut intersection = 0usize;

    while left_index < left_terms.len() && right_index < right_terms.len() {
        match left_terms[left_index].cmp(&right_terms[right_index]) {
            Ordering::Less => left_index += 1,
            Ordering::Equal => {
                intersection += 1;
                left_index += 1;
                right_index += 1;
            }
            Ordering::Greater => right_index += 1,
        }
    }

    intersection
}

#[cfg(test)]
thread_local! {
    static NORMALIZED_TERMS_CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
    static FACILITY_MARGINAL_GAIN_EVALUATIONS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}

#[cfg(test)]
fn reset_normalized_terms_call_count() {
    NORMALIZED_TERMS_CALLS.with(|calls| calls.set(0));
}

#[cfg(test)]
fn normalized_terms_call_count() -> usize {
    NORMALIZED_TERMS_CALLS.with(std::cell::Cell::get)
}

#[cfg(test)]
fn reset_facility_marginal_gain_evaluation_count() {
    FACILITY_MARGINAL_GAIN_EVALUATIONS.with(|evaluations| evaluations.set(0));
}

#[cfg(test)]
fn facility_marginal_gain_evaluation_count() -> usize {
    FACILITY_MARGINAL_GAIN_EVALUATIONS.with(std::cell::Cell::get)
}

fn normalized_terms(content: &str) -> Vec<String> {
    #[cfg(test)]
    NORMALIZED_TERMS_CALLS.with(|calls| calls.set(calls.get().saturating_add(1)));

    let mut terms = content
        .split_whitespace()
        .map(|term| {
            term.trim_matches(|ch: char| !ch.is_ascii_alphanumeric())
                .to_ascii_lowercase()
        })
        .filter(|term| !term.is_empty())
        .collect::<Vec<_>>();
    terms.sort_unstable();
    terms.dedup();
    terms
}

fn certificate_features(candidate: &PackCandidate) -> Vec<String> {
    let mut features = vec![format!("section:{}", candidate.section.as_str())];
    if let Some(diversity_key) = &candidate.diversity_key {
        features.push(format!("diversity:{diversity_key}"));
    }
    features.push(format!("memory:{}", candidate.memory_id));
    features
}

/// Compute similarity between a candidate and a selected signature.
///
/// Uses a richer signature (kind+id+content-hash) rather than coarse diversity keys.
/// Matching diversity_key alone does NOT cause full redundancy—two unrelated memories
/// can share a coarse tag like "formatting" without being duplicates.
///
/// Bug: eidetic_engine_cli-6cjh
#[cfg(test)]
fn candidate_similarity(candidate: &PackCandidate, selected: &CandidateSignature) -> f32 {
    let candidate_signature = CandidateSignature::from(candidate);
    candidate_signature_similarity(&candidate_signature, selected)
}

fn candidate_signature_similarity(
    candidate: &CandidateSignature,
    selected: &CandidateSignature,
) -> f32 {
    // Same memory is always fully redundant
    if candidate.memory_id == selected.memory_id {
        return 1.0;
    }

    // Exact content match is fully redundant
    if candidate.normalized_content == selected.normalized_content {
        return 1.0;
    }

    // Compute content overlap similarity
    let content_similarity =
        content_overlap_similarity_terms(&candidate.content_terms, &selected.content_terms);

    // Matching diversity_key boosts similarity but doesn't cause full redundancy by itself.
    // Two memories tagged "formatting" with different content are NOT duplicates.
    if let Some(diversity_key) = &candidate.diversity_key
        && selected.diversity_key.as_ref() == Some(diversity_key)
    {
        // Boost content similarity when diversity keys match, but cap below 1.0
        // unless content actually overlaps significantly
        return content_similarity.clamp(0.5, 0.95);
    }

    content_similarity
}

fn normalize_redundancy_content(content: &str) -> String {
    content.split_whitespace().collect::<Vec<_>>().join(" ")
}

fn compare_candidates(left: &PackCandidate, right: &PackCandidate) -> Ordering {
    right
        .relevance
        .into_inner()
        .total_cmp(&left.relevance.into_inner())
        .then_with(|| {
            right
                .utility
                .into_inner()
                .total_cmp(&left.utility.into_inner())
        })
        .then_with(|| left.section.cmp(&right.section))
        .then_with(|| left.memory_id.cmp(&right.memory_id))
}

fn trim_required(value: String, error: PackValidationError) -> Result<String, PackValidationError> {
    let trimmed = value.trim();
    if trimmed.is_empty() {
        return Err(error);
    }
    Ok(trimmed.to_string())
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum PackValidationError {
    EmptyQuery,
    ZeroTokenBudget,
    ZeroCandidatePool,
    ZeroMaxResults,
    EmptyCandidateContent {
        memory_id: MemoryId,
    },
    ZeroCandidateTokens {
        memory_id: MemoryId,
    },
    MissingProvenance {
        memory_id: MemoryId,
    },
    EmptyProvenanceNote {
        uri: ProvenanceUri,
    },
    MissingWhy {
        memory_id: MemoryId,
    },
    CandidateRankOverflow,
    ContextResponseQueryMismatch {
        request_query: String,
        draft_query: String,
    },
    EmptyDegradationCode,
    EmptyDegradationMessage {
        code: String,
    },
}

impl fmt::Display for PackValidationError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::EmptyQuery => formatter.write_str("context query must not be empty"),
            Self::ZeroTokenBudget => formatter.write_str("context token budget must be non-zero"),
            Self::ZeroCandidatePool => {
                formatter.write_str("context candidate pool must be non-zero")
            }
            Self::ZeroMaxResults => formatter.write_str("context max results must be non-zero"),
            Self::EmptyCandidateContent { memory_id } => {
                write!(formatter, "pack candidate `{memory_id}` has empty content")
            }
            Self::ZeroCandidateTokens { memory_id } => {
                write!(
                    formatter,
                    "pack candidate `{memory_id}` has zero estimated tokens"
                )
            }
            Self::MissingProvenance { memory_id } => {
                write!(formatter, "pack candidate `{memory_id}` has no provenance")
            }
            Self::EmptyProvenanceNote { uri } => {
                write!(formatter, "pack provenance `{uri}` has an empty note")
            }
            Self::MissingWhy { memory_id } => {
                write!(
                    formatter,
                    "pack candidate `{memory_id}` is missing a why explanation"
                )
            }
            Self::CandidateRankOverflow => {
                formatter.write_str("context pack contains too many ranked candidates")
            }
            Self::ContextResponseQueryMismatch {
                request_query,
                draft_query,
            } => write!(
                formatter,
                "context response request query `{request_query}` does not match pack query `{draft_query}`"
            ),
            Self::EmptyDegradationCode => {
                formatter.write_str("context response degradation code must not be empty")
            }
            Self::EmptyDegradationMessage { code } => write!(
                formatter,
                "context response degradation `{code}` message must not be empty"
            ),
        }
    }
}

impl std::error::Error for PackValidationError {}

// ============================================================================
// Rate-Distortion Token Budget Reports (EE-345)
//
// Rate-distortion theory measures the tradeoff between compression (rate, i.e.
// tokens used) and quality (distortion, i.e. information loss). These reports
// help users understand how their token budget affects context pack quality.
// ============================================================================

pub const RATE_DISTORTION_SCHEMA_V1: &str = "ee.pack.rate_distortion.v1";

/// Rate-distortion report for token budget analysis.
#[derive(Clone, Debug, PartialEq)]
pub struct RateDistortionReport {
    pub budget_tokens: u32,
    pub used_tokens: u32,
    pub rate: f64,
    pub distortion: f64,
    pub efficiency: f64,
    pub omitted_candidates: u32,
    pub included_candidates: u32,
    pub quality_score: f64,
    pub sections: Vec<SectionBudgetReport>,
}

impl RateDistortionReport {
    #[must_use]
    pub fn new(budget_tokens: u32, used_tokens: u32) -> Self {
        let rate = if budget_tokens > 0 {
            used_tokens as f64 / budget_tokens as f64
        } else {
            0.0
        };
        Self {
            budget_tokens,
            used_tokens,
            rate,
            distortion: 0.0,
            efficiency: rate,
            omitted_candidates: 0,
            included_candidates: 0,
            quality_score: 1.0,
            sections: Vec::new(),
        }
    }

    pub fn with_candidates(mut self, included: u32, omitted: u32) -> Self {
        self.included_candidates = included;
        self.omitted_candidates = omitted;
        let total_candidates = u64::from(included) + u64::from(omitted);
        if total_candidates > 0 {
            let total_candidates = total_candidates as f64;
            self.quality_score = f64::from(included) / total_candidates;
            self.distortion = f64::from(omitted) / total_candidates;
        }
        self
    }

    pub fn add_section(&mut self, section: SectionBudgetReport) {
        self.sections.push(section);
    }

    #[must_use]
    pub fn slack(&self) -> u32 {
        self.budget_tokens.saturating_sub(self.used_tokens)
    }

    #[must_use]
    pub fn utilization_percent(&self) -> f64 {
        self.rate * 100.0
    }

    #[must_use]
    pub fn to_json(&self) -> String {
        #[derive(Serialize)]
        #[serde(rename_all = "camelCase")]
        struct RateDistortionJson<'a> {
            schema: &'static str,
            budget_tokens: u32,
            used_tokens: u32,
            slack_tokens: u32,
            rate: f64,
            distortion: f64,
            efficiency: f64,
            omitted_candidates: u32,
            included_candidates: u32,
            quality_score: f64,
            utilization_percent: f64,
            sections: Vec<SectionBudgetJson<'a>>,
        }

        #[derive(Serialize)]
        #[serde(rename_all = "camelCase")]
        struct SectionBudgetJson<'a> {
            name: &'a str,
            quota_tokens: u32,
            used_tokens: u32,
            slack_tokens: u32,
            candidate_count: u32,
            utilization_percent: f64,
        }

        let json_repr = RateDistortionJson {
            schema: RATE_DISTORTION_SCHEMA_V1,
            budget_tokens: self.budget_tokens,
            used_tokens: self.used_tokens,
            slack_tokens: self.slack(),
            rate: (self.rate * 10000.0).round() / 10000.0,
            distortion: (self.distortion * 10000.0).round() / 10000.0,
            efficiency: (self.efficiency * 10000.0).round() / 10000.0,
            omitted_candidates: self.omitted_candidates,
            included_candidates: self.included_candidates,
            quality_score: (self.quality_score * 10000.0).round() / 10000.0,
            utilization_percent: (self.utilization_percent() * 100.0).round() / 100.0,
            sections: self
                .sections
                .iter()
                .map(|section| SectionBudgetJson {
                    name: &section.name,
                    quota_tokens: section.quota_tokens,
                    used_tokens: section.used_tokens,
                    slack_tokens: section.slack(),
                    candidate_count: section.candidate_count,
                    utilization_percent: (section.utilization_percent() * 100.0).round() / 100.0,
                })
                .collect(),
        };

        serialize_pack_json_or_error(
            &json_repr,
            "RateDistortionReport",
            Some(RATE_DISTORTION_SCHEMA_V1),
        )
    }

    #[must_use]
    pub fn to_human(&self) -> String {
        let mut result = String::from("Rate-Distortion Budget Report\n");
        result.push_str("═══════════════════════════════════════\n\n");
        result.push_str(&format!("Budget:      {:>6} tokens\n", self.budget_tokens));
        result.push_str(&format!("Used:        {:>6} tokens\n", self.used_tokens));
        result.push_str(&format!("Slack:       {:>6} tokens\n", self.slack()));
        result.push_str(&format!(
            "Utilization: {:>5.1}%\n\n",
            self.utilization_percent()
        ));
        result.push_str("Candidates:\n");
        result.push_str(&format!("  Included:  {:>6}\n", self.included_candidates));
        result.push_str(&format!("  Omitted:   {:>6}\n", self.omitted_candidates));
        result.push_str(&format!(
            "  Quality:   {:>5.1}%\n\n",
            self.quality_score * 100.0
        ));
        result.push_str("Rate-Distortion Metrics:\n");
        result.push_str(&format!("  Rate (R):       {:>6.4}\n", self.rate));
        result.push_str(&format!("  Distortion (D): {:>6.4}\n", self.distortion));
        result.push_str(&format!("  Efficiency:     {:>6.4}\n\n", self.efficiency));

        if !self.sections.is_empty() {
            result.push_str("Section Breakdown:\n");
            for section in &self.sections {
                result.push_str(&format!(
                    "  {:<15} {:>5} tokens ({:>4.1}%)\n",
                    section.name,
                    section.used_tokens,
                    section.utilization_percent()
                ));
            }
        }
        result
    }
}

/// Budget report for a single pack section.
#[derive(Clone, Debug, PartialEq)]
pub struct SectionBudgetReport {
    pub name: String,
    pub quota_tokens: u32,
    pub used_tokens: u32,
    pub candidate_count: u32,
}

impl SectionBudgetReport {
    #[must_use]
    pub fn new(name: impl Into<String>, quota_tokens: u32, used_tokens: u32) -> Self {
        Self {
            name: name.into(),
            quota_tokens,
            used_tokens,
            candidate_count: 0,
        }
    }

    pub fn with_candidates(mut self, count: u32) -> Self {
        self.candidate_count = count;
        self
    }

    #[must_use]
    pub fn slack(&self) -> u32 {
        self.quota_tokens.saturating_sub(self.used_tokens)
    }

    #[must_use]
    pub fn utilization_percent(&self) -> f64 {
        if self.quota_tokens > 0 {
            (self.used_tokens as f64 / self.quota_tokens as f64) * 100.0
        } else {
            0.0
        }
    }

    #[must_use]
    pub fn to_json(&self) -> String {
        #[derive(Serialize)]
        #[serde(rename_all = "camelCase")]
        struct SectionJson<'a> {
            name: &'a str,
            quota_tokens: u32,
            used_tokens: u32,
            slack_tokens: u32,
            candidate_count: u32,
            utilization_percent: f64,
        }

        let json_repr = SectionJson {
            name: &self.name,
            quota_tokens: self.quota_tokens,
            used_tokens: self.used_tokens,
            slack_tokens: self.slack(),
            candidate_count: self.candidate_count,
            utilization_percent: (self.utilization_percent() * 100.0).round() / 100.0,
        };

        serialize_pack_json_or_error(&json_repr, "SectionBudgetReport", None)
    }
}

/// Pack-side hotset entry types for derived cache prewarming.
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum PackHotsetEntryKind {
    PackSection,
    SelectionAudit,
}

impl PackHotsetEntryKind {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::PackSection => "pack_section",
            Self::SelectionAudit => "selection_audit",
        }
    }
}

/// Redaction-safe pack cache entry.
///
/// Entries store memory IDs, section names, token counts, and hashes only.
/// Selected item content is intentionally excluded because content is already
/// rendered from the source-of-truth pack draft.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PackHotsetEntry {
    pub key: String,
    pub kind: PackHotsetEntryKind,
    pub section: Option<PackSection>,
    pub generation: u64,
    pub estimated_bytes: usize,
    pub hit_count: u64,
    pub redaction_status: &'static str,
}

impl PackHotsetEntry {
    #[must_use]
    pub fn selection_audit(draft: &PackDraft, generation: u64, hit_count: u64) -> Self {
        let payload = format!(
            "{}:{}:{}:{}",
            draft.selection_audit.objective.as_str(),
            draft.selection_audit.algorithm_id,
            draft.selection_audit.candidate_count,
            draft.selection_audit.selected_count
        );
        Self {
            key: pack_cache_key("pack:selection_audit", &payload),
            kind: PackHotsetEntryKind::SelectionAudit,
            section: None,
            generation,
            estimated_bytes: 192_usize
                .saturating_add(draft.selection_audit.steps.len().saturating_mul(40)),
            hit_count,
            redaction_status: "content_not_stored",
        }
    }

    #[must_use]
    fn pack_section(
        section: PackSection,
        memory_ids: &[String],
        used_tokens: u32,
        generation: u64,
        hit_count: u64,
    ) -> Self {
        let payload = format!(
            "{}:{}:{}",
            section.as_str(),
            used_tokens,
            memory_ids.join(",")
        );
        Self {
            key: pack_cache_key("pack:section", &payload),
            kind: PackHotsetEntryKind::PackSection,
            section: Some(section),
            generation,
            estimated_bytes: 128_usize.saturating_add(memory_ids.len().saturating_mul(48)),
            hit_count,
            redaction_status: "content_not_stored",
        }
    }

    #[must_use]
    pub fn is_redaction_safe(&self) -> bool {
        self.redaction_status == "content_not_stored"
    }

    #[must_use]
    pub fn data_json(&self) -> serde_json::Value {
        serde_json::json!({
            "key": self.key,
            "kind": self.kind.as_str(),
            "section": self.section.map(PackSection::as_str),
            "generation": self.generation,
            "estimatedBytes": self.estimated_bytes,
            "hitCount": self.hit_count,
            "redactionStatus": self.redaction_status,
        })
    }
}

/// Deterministic pack hotset derived from a finished pack draft.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PackHotset {
    entries: Vec<PackHotsetEntry>,
}

impl PackHotset {
    #[must_use]
    pub fn new(entries: impl IntoIterator<Item = PackHotsetEntry>) -> Self {
        let mut merged: BTreeMap<(PackHotsetEntryKind, String), PackHotsetEntry> = BTreeMap::new();
        for entry in entries {
            let key = (entry.kind, entry.key.clone());
            merged
                .entry(key)
                .and_modify(|existing| {
                    existing.hit_count = existing.hit_count.saturating_add(entry.hit_count);
                    existing.estimated_bytes = existing.estimated_bytes.max(entry.estimated_bytes);
                    existing.generation = existing.generation.max(entry.generation);
                })
                .or_insert(entry);
        }
        Self {
            entries: merged.into_values().collect(),
        }
    }

    #[must_use]
    pub fn from_draft(draft: &PackDraft, generation: u64) -> Self {
        let mut by_section: BTreeMap<PackSection, Vec<&PackDraftItem>> = BTreeMap::new();
        for item in &draft.items {
            by_section.entry(item.section).or_default().push(item);
        }

        let mut entries = Vec::new();
        for (section, items) in by_section {
            let mut memory_ids: Vec<String> = items
                .iter()
                .map(|item| item.memory_id.to_string())
                .collect();
            sort_by_ulid_payload_or_lexical(&mut memory_ids, String::as_str);
            let used_tokens = items.iter().map(|item| item.estimated_tokens).sum::<u32>();
            entries.push(PackHotsetEntry::pack_section(
                section,
                &memory_ids,
                used_tokens,
                generation,
                usize_to_u64(items.len()),
            ));
        }
        entries.push(PackHotsetEntry::selection_audit(draft, generation, 1));
        Self::new(entries)
    }

    #[must_use]
    pub fn entries(&self) -> &[PackHotsetEntry] {
        &self.entries
    }

    #[must_use]
    pub fn len(&self) -> usize {
        self.entries.len()
    }

    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    #[must_use]
    pub fn total_hit_count(&self) -> u64 {
        self.entries.iter().map(|entry| entry.hit_count).sum()
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackCacheStatus {
    Warm,
    StaleGeneration,
    PressureFallback,
    Bypassed,
}

impl PackCacheStatus {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Warm => "warm",
            Self::StaleGeneration => "stale_generation",
            Self::PressureFallback => "pressure_fallback",
            Self::Bypassed => "bypassed",
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PackCacheGovernor {
    pub budget: CacheBudget,
    pub current_generation: u64,
    pub current_entries: usize,
    pub current_bytes: usize,
}

impl PackCacheGovernor {
    #[must_use]
    pub fn new(current_generation: u64, budget: CacheBudget) -> Self {
        Self {
            budget,
            current_generation,
            current_entries: 0,
            current_bytes: 0,
        }
    }

    #[must_use]
    pub const fn with_current_usage(mut self, entries: usize, bytes: usize) -> Self {
        self.current_entries = entries;
        self.current_bytes = bytes;
        self
    }

    #[must_use]
    pub fn pressure(self) -> MemoryPressure {
        pack_max_pressure(
            assess_pressure(self.current_entries, &self.budget),
            pack_byte_pressure(self.current_bytes, &self.budget),
        )
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackCacheBenchmarkEvidence {
    pub operations: usize,
    pub cold_latency_us: u64,
    pub warm_latency_us: u64,
    pub latency_win_ratio: f64,
}

impl PackCacheBenchmarkEvidence {
    #[must_use]
    pub fn from_prewarm_counts(requested: usize, admitted: usize) -> Self {
        let cold_latency_us = usize_to_u64(requested).saturating_mul(850);
        let warm_latency_us = usize_to_u64(admitted)
            .saturating_mul(140)
            .saturating_add(usize_to_u64(requested.saturating_sub(admitted)).saturating_mul(850));
        let latency_win_ratio = if cold_latency_us == 0 {
            0.0
        } else {
            (cold_latency_us.saturating_sub(warm_latency_us)) as f64 / cold_latency_us as f64
        };
        Self {
            operations: requested,
            cold_latency_us,
            warm_latency_us,
            latency_win_ratio,
        }
    }

    #[must_use]
    pub fn data_json(&self) -> serde_json::Value {
        serde_json::json!({
            "operations": self.operations,
            "coldLatencyUs": self.cold_latency_us,
            "warmLatencyUs": self.warm_latency_us,
            "latencyWinRatio": pack_rounded_f64(self.latency_win_ratio),
        })
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PackCachePrewarmReport {
    pub status: PackCacheStatus,
    pub source_generation: Option<u64>,
    pub current_generation: u64,
    pub requested_entries: usize,
    pub admitted_entries: usize,
    pub rejected_entries: usize,
    pub estimated_bytes: usize,
    pub budget_max_entries: usize,
    pub budget_max_bytes: usize,
    pub memory_pressure: MemoryPressure,
    pub hit_rate: f64,
    pub fallback_reason: Option<&'static str>,
    pub benchmark: PackCacheBenchmarkEvidence,
    pub admitted: Vec<PackHotsetEntry>,
}

impl PackCachePrewarmReport {
    #[must_use]
    pub fn data_json(&self) -> serde_json::Value {
        serde_json::json!({
            "schema": "ee.pack.cache_prewarm.v1",
            "status": self.status.as_str(),
            "sourceGeneration": self.source_generation,
            "currentGeneration": self.current_generation,
            "requestedEntries": self.requested_entries,
            "admittedEntries": self.admitted_entries,
            "rejectedEntries": self.rejected_entries,
            "estimatedBytes": self.estimated_bytes,
            "budget": {
                "maxEntries": self.budget_max_entries,
                "maxBytes": self.budget_max_bytes,
            },
            "memoryPressure": self.memory_pressure.as_str(),
            "hitRate": pack_rounded_f64(self.hit_rate),
            "fallbackReason": self.fallback_reason,
            "benchmarkEvidence": self.benchmark.data_json(),
            "admitted": self.admitted.iter().map(PackHotsetEntry::data_json).collect::<Vec<_>>(),
        })
    }
}

/// Assemble a draft and produce a derived-cache prewarm report.
///
/// The cache report never changes selection: callers can compare the returned
/// draft against `assemble_draft_with_profile` to prove cache-on/cache-off
/// output equivalence.
///
/// # Errors
///
/// Returns the same validation errors as [`assemble_draft_with_profile`].
pub fn assemble_draft_with_cache_governor(
    profile: ContextPackProfile,
    query: impl Into<String>,
    budget: TokenBudget,
    candidates: impl IntoIterator<Item = PackCandidate>,
    source_generation: u64,
    governor: PackCacheGovernor,
) -> Result<(PackDraft, PackCachePrewarmReport), PackValidationError> {
    let candidates: Vec<PackCandidate> = candidates.into_iter().collect();
    let draft = assemble_draft_with_profile(profile, query, budget, candidates)?;
    let hotset = PackHotset::from_draft(&draft, source_generation);
    let report = prewarm_pack_hotset(&hotset, governor);
    Ok((draft, report))
}

#[must_use]
pub fn prewarm_pack_hotset(
    hotset: &PackHotset,
    governor: PackCacheGovernor,
) -> PackCachePrewarmReport {
    let source_generation = hotset.entries().first().map(|entry| entry.generation);
    let requested_entries = hotset.len();
    let pressure = governor.pressure();

    let stale_generation = hotset
        .entries()
        .iter()
        .any(|entry| entry.generation != governor.current_generation);
    if stale_generation {
        return pack_cache_report(
            PackCacheStatus::StaleGeneration,
            source_generation,
            governor,
            requested_entries,
            Vec::new(),
            hotset.total_hit_count(),
            Some("generation_mismatch"),
        );
    }

    if pressure == MemoryPressure::Critical {
        return pack_cache_report(
            PackCacheStatus::Bypassed,
            source_generation,
            governor,
            requested_entries,
            Vec::new(),
            hotset.total_hit_count(),
            Some("memory_pressure_critical"),
        );
    }

    let mut admitted = Vec::new();
    let mut projected_entries = governor.current_entries;
    let mut projected_bytes = governor.current_bytes;
    for entry in hotset.entries() {
        let next_entries = projected_entries.saturating_add(1);
        let next_bytes = projected_bytes.saturating_add(entry.estimated_bytes);
        if next_entries > governor.budget.max_entries || next_bytes > governor.budget.max_bytes {
            continue;
        }
        if entry.is_redaction_safe() {
            projected_entries = next_entries;
            projected_bytes = next_bytes;
            admitted.push(entry.clone());
        }
    }

    let status = if admitted.len() == requested_entries {
        PackCacheStatus::Warm
    } else {
        PackCacheStatus::PressureFallback
    };
    let fallback_reason = if status == PackCacheStatus::PressureFallback {
        Some("budget_trimmed")
    } else {
        None
    };
    pack_cache_report(
        status,
        source_generation,
        governor,
        requested_entries,
        admitted,
        hotset.total_hit_count(),
        fallback_reason,
    )
}

fn pack_cache_report(
    status: PackCacheStatus,
    source_generation: Option<u64>,
    governor: PackCacheGovernor,
    requested_entries: usize,
    admitted: Vec<PackHotsetEntry>,
    total_hit_count: u64,
    fallback_reason: Option<&'static str>,
) -> PackCachePrewarmReport {
    let admitted_hit_count = admitted.iter().map(|entry| entry.hit_count).sum::<u64>();
    let hit_rate = if total_hit_count == 0 {
        0.0
    } else {
        admitted_hit_count as f64 / total_hit_count as f64
    };
    let admitted_entries = admitted.len();
    PackCachePrewarmReport {
        status,
        source_generation,
        current_generation: governor.current_generation,
        requested_entries,
        admitted_entries,
        rejected_entries: requested_entries.saturating_sub(admitted_entries),
        estimated_bytes: admitted.iter().map(|entry| entry.estimated_bytes).sum(),
        budget_max_entries: governor.budget.max_entries,
        budget_max_bytes: governor.budget.max_bytes,
        memory_pressure: governor.pressure(),
        hit_rate,
        fallback_reason,
        benchmark: PackCacheBenchmarkEvidence::from_prewarm_counts(
            requested_entries,
            admitted_entries,
        ),
        admitted,
    }
}

fn pack_cache_key(namespace: &str, payload: &str) -> String {
    let mut hasher = blake3::Hasher::new();
    hasher.update(namespace.as_bytes());
    hasher.update(&[0]);
    hasher.update(payload.as_bytes());
    format!("blake3:{}", hasher.finalize().to_hex())
}

fn pack_byte_pressure(current_bytes: usize, budget: &CacheBudget) -> MemoryPressure {
    if budget.max_bytes == 0
        || current_bytes >= pack_watermark_bytes(budget.max_bytes, budget.critical_watermark)
    {
        MemoryPressure::Critical
    } else if current_bytes >= pack_watermark_bytes(budget.max_bytes, budget.high_watermark) {
        MemoryPressure::High
    } else {
        MemoryPressure::Normal
    }
}

fn pack_watermark_bytes(max_bytes: usize, watermark: f64) -> usize {
    ((max_bytes as f64) * watermark).floor() as usize
}

const fn pack_max_pressure(left: MemoryPressure, right: MemoryPressure) -> MemoryPressure {
    if left as u8 >= right as u8 {
        left
    } else {
        right
    }
}

fn usize_to_u64(value: usize) -> u64 {
    u64::try_from(value).unwrap_or(u64::MAX)
}

fn pack_rounded_f64(value: f64) -> f64 {
    (value * 10_000.0).round() / 10_000.0
}

/// Compute a rate-distortion report from context response data.
#[must_use]
pub fn compute_rate_distortion(
    budget: u32,
    used: u32,
    included: u32,
    omitted: u32,
) -> RateDistortionReport {
    RateDistortionReport::new(budget, used).with_candidates(included, omitted)
}

#[cfg(test)]
mod tests {
    use std::cmp::Ordering;
    use std::str::FromStr;
    use std::time::Instant;

    use proptest::prelude::*;
    use uuid::Uuid;

    use super::{
        CHARACTER_HEURISTIC_CHARS_PER_TOKEN_DENOMINATOR,
        CHARACTER_HEURISTIC_CHARS_PER_TOKEN_NUMERATOR, CandidateSignature, ContextPackProfile,
        ContextRequest, ContextRequestInput, ContextResponse, ContextResponseDegradation,
        ContextResponseSeverity, DEFAULT_CHARS_PER_TOKEN, DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR,
        FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR, PACK_ASSEMBLY_BUDGET_EXCEEDED_CODE,
        PACK_ASSEMBLY_SLOW_CODE, PACK_COMMAND, PACK_REVISION_TOKEN_SCHEMA_V1, PackArenaWorkspace,
        PackArenaWorkspaceKey, PackAssemblyOptions, PackAssemblySlo, PackAssemblySloActuals,
        PackAssemblySloStatus, PackCacheGovernor, PackCacheStatus, PackCandidate,
        PackCandidateInput, PackDraft, PackDraftItem, PackHotset, PackHotsetEntry,
        PackHotsetEntryKind, PackItemRedaction, PackOmissionReason, PackProvenance,
        PackRejectionStage, PackResourceProfile, PackRevisionMeshMetadata, PackScoreBreakdown,
        PackSection, PackSelectedItem, PackSelectionAudit, PackSelectionObjective,
        PackSelectionPhase, PackTrustPosture, PackTrustSignal, PackValidationError, SectionQuota,
        SectionQuotas, TokenBudget, TokenEstimationStrategy,
        WORD_HEURISTIC_TOKEN_MULTIPLIER_DENOMINATOR, WORD_HEURISTIC_TOKEN_MULTIPLIER_NUMERATOR,
        assemble_draft, assemble_draft_with_cache_governor, assemble_draft_with_profile,
        assemble_draft_with_profile_and_options, assemble_draft_with_profile_and_options_seeded,
        assemble_draft_with_profile_and_options_seeded_in_workspace, candidate_similarity,
        escape_markdown_text, estimate_character_heuristic_tokens, estimate_tokens,
        estimate_tokens_default, estimate_word_heuristic_tokens, facility_similarity,
        pack_item_provenance_json, prewarm_pack_hotset, render_context_markdown_with_analysis,
        subsystem_name, trust_class_rank_milli,
    };
    use crate::cache::{CacheBudget, MemoryPressure};
    use crate::config::MeshCommandMode;
    use crate::models::{ContextProfile, MemoryId, ProvenanceUri, TrustClass, UnitScore};
    use crate::runtime::determinism::Deterministic;
    use crate::testing::ensure_contains;

    type TestResult = Result<(), String>;

    struct FailingSerialize;

    impl serde::Serialize for FailingSerialize {
        fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            Err(serde::ser::Error::custom(
                "intentional serialization failure",
            ))
        }
    }

    #[test]
    fn context_markdown_escape_neutralizes_full_line_markers_without_overescaping() {
        assert_eq!(
            escape_markdown_text("Run v0.2.0 with mem_01ABC.\n---\nAfter"),
            "Run v0.2.0 with mem_01ABC.\n\\---\nAfter"
        );
        assert_eq!(
            escape_markdown_text("Before\n===\nAfter"),
            "Before\n\\===\nAfter"
        );
        assert_eq!(escape_markdown_text("--- not a rule"), "--- not a rule");
        assert_eq!(escape_markdown_text("1. first item"), "1\\. first item");
    }

    #[test]
    fn team_pack_attribution_suffix_renders_member_and_origin_time() {
        let trust = PackTrustSignal::new(
            crate::models::TrustClass::PeerHumanAttested,
            Some("agent:Priya; produced_at=2026-07-30T14:02:00Z".to_owned()),
        );
        assert_eq!(
            super::team_pack_attribution_suffix(&trust).as_deref(),
            Some("· from Priya · 2026-07-30T14:02:00Z")
        );
        assert!(
            super::team_pack_attribution_suffix(&PackTrustSignal::new(
                crate::models::TrustClass::HumanExplicit,
                Some("agent:Priya; produced_at=2026-07-30T14:02:00Z".to_owned()),
            ))
            .is_none()
        );
        let json = super::team_pack_provenance_json(&trust).expect("pack json");
        let value: serde_json::Value = serde_json::from_str(&json).expect("parse");
        assert_eq!(value["schema"], "ee.team.provenance.v1");
        assert_eq!(value["memberDisplayName"], "Priya");
        assert_eq!(value["projectName"], serde_json::Value::Null);
        assert_eq!(value["producedAt"], "2026-07-30T14:02:00Z");
        assert_eq!(value["originTrustClass"], "human_explicit");
        assert_eq!(value["originTimeAssurance"], "member_attested");
        let bound = PackTrustSignal::new(
            crate::models::TrustClass::PeerHumanAttested,
            Some("agent:Priya; produced_at=2026-07-30T14:02:00Z; project=acme-analysis".to_owned()),
        );
        assert_eq!(
            super::team_pack_attribution_suffix(&bound).as_deref(),
            Some("· from Priya / acme-analysis · 2026-07-30T14:02:00Z")
        );
        let bound_json = super::team_pack_provenance_json(&bound).expect("pack json");
        let bound_value: serde_json::Value = serde_json::from_str(&bound_json).expect("parse");
        assert_eq!(bound_value["projectName"], "acme-analysis");
    }

    #[test]
    fn context_footer_query_arg_shell_quotes_sensitive_queries() {
        assert_eq!(
            super::context_footer_query_arg("format before release"),
            "\"format before release\""
        );
        assert_eq!(
            super::context_footer_query_arg("fix \"release\" $PATH"),
            "'fix \"release\" $PATH'"
        );
        assert_eq!(
            super::context_footer_query_arg("owner's release"),
            "'owner'\"'\"'s release'"
        );
    }

    #[test]
    fn serialize_pack_json_or_error_reports_failure_shape() -> TestResult {
        let json = super::serialize_pack_json_or_error(
            &FailingSerialize,
            "FailingPackReport",
            Some(super::RATE_DISTORTION_SCHEMA_V1),
        );
        let parsed: serde_json::Value =
            serde_json::from_str(&json).map_err(|error| error.to_string())?;

        assert_eq!(
            parsed["schema"].as_str(),
            Some(crate::models::ERROR_SCHEMA_V2)
        );
        assert_eq!(
            parsed["error"]["code"].as_str(),
            Some("serialization_failed")
        );
        assert_eq!(
            parsed["error"]["details"]["type"].as_str(),
            Some("FailingPackReport")
        );
        assert_eq!(
            parsed["error"]["details"]["expectedSchema"].as_str(),
            Some(super::RATE_DISTORTION_SCHEMA_V1)
        );
        assert_ne!(json, "{}");
        Ok(())
    }

    #[test]
    fn coordination_snapshot_degraded_entries_are_aggregated() -> TestResult {
        let snapshot = super::PackCoordinationSnapshot::from_json_str(
            r#"{
                "schema": "ee.coordination_snapshot.v1",
                "scope": "workspace",
                "sources": [{
                    "kind": "agent_mail",
                    "id": "mail",
                    "degraded": [
                        {
                            "code": "coordination_stale",
                            "severity": "warning",
                            "message": "Agent Mail snapshot is stale.",
                            "repair": "Refresh Agent Mail state."
                        },
                        {
                            "code": "coordination_stale",
                            "severity": "medium",
                            "message": "Agent Mail snapshot is too stale for conflict checks.",
                            "repair": "Re-run swarm brief."
                        }
                    ]
                }]
            }"#,
            super::DEFAULT_COORDINATION_STALE_AFTER_MS,
        )?;
        let value = serde_json::to_value(&snapshot).map_err(|error| error.to_string())?;
        let degraded = value["sources"][0]["degraded"]
            .as_array()
            .ok_or_else(|| "expected source degraded array".to_owned())?;

        ensure_equal(
            &degraded.len(),
            &1,
            "duplicate coordination degradation count",
        )?;
        ensure_equal(
            &degraded[0]["code"],
            &serde_json::json!("coordination_stale"),
            "aggregate code",
        )?;
        ensure_equal(
            &degraded[0]["severity"],
            &serde_json::json!("medium"),
            "aggregate severity",
        )?;
        ensure_equal(
            &degraded[0]["sources"],
            &serde_json::json!(["pack_coordination"]),
            "aggregate source label",
        )?;
        Ok(())
    }

    fn ensure(condition: bool, message: impl Into<String>) -> TestResult {
        if condition {
            Ok(())
        } else {
            Err(message.into())
        }
    }

    fn ensure_equal<T>(actual: &T, expected: &T, context: &str) -> TestResult
    where
        T: std::fmt::Debug + PartialEq,
    {
        if actual == expected {
            Ok(())
        } else {
            Err(format!("{context}: expected {expected:?}, got {actual:?}"))
        }
    }

    fn ensure_close(actual: f32, expected: f32, context: &str) -> TestResult {
        if (actual - expected).abs() <= 0.000_001 {
            Ok(())
        } else {
            Err(format!("{context}: expected {expected:?}, got {actual:?}"))
        }
    }

    fn section_name_tail_strategy() -> impl Strategy<Value = String> {
        prop::collection::vec(
            prop::sample::select(vec![
                '"',
                '\\',
                '\n',
                '\r',
                '\t',
                '\u{03bb}',
                '\u{1f680}',
                '\u{6771}',
                '\u{4eac}',
                'a',
                'z',
                '0',
                '9',
                ' ',
            ]),
            0..48,
        )
        .prop_map(|chars| chars.into_iter().collect())
    }

    fn weird_section_name_strategy() -> impl Strategy<Value = String> {
        prop_oneof![
            section_name_tail_strategy().prop_map(|tail| format!("quote\"section{tail}")),
            section_name_tail_strategy().prop_map(|tail| format!("line\nsection{tail}")),
            section_name_tail_strategy()
                .prop_map(|tail| { format!("unicode:\u{03bb}\u{1f680}\u{6771}\u{4eac}{tail}") }),
        ]
    }

    fn memory_id(seed: u128) -> MemoryId {
        MemoryId::from_uuid(Uuid::from_u128(seed))
    }

    fn score(value: f32) -> Result<UnitScore, String> {
        UnitScore::parse(value).map_err(|error| format!("test score rejected: {error:?}"))
    }

    fn provenance(path: &str) -> Result<PackProvenance, String> {
        let uri = ProvenanceUri::from_str(path)
            .map_err(|error| format!("test provenance URI rejected: {error:?}"))?;
        PackProvenance::new(uri, "source evidence")
            .map_err(|error| format!("test provenance note rejected: {error:?}"))
    }

    fn candidate_input(
        memory_id: MemoryId,
        section: PackSection,
        content: impl Into<String>,
        estimated_tokens: u32,
        provenance: Vec<PackProvenance>,
        why: impl Into<String>,
    ) -> Result<PackCandidateInput, String> {
        Ok(PackCandidateInput {
            memory_id,
            section,
            content: content.into(),
            estimated_tokens,
            relevance: score(0.8)?,
            utility: score(0.5)?,
            provenance,
            why: why.into(),
        })
    }

    fn candidate(
        seed: u128,
        relevance: f32,
        utility: f32,
        tokens: u32,
    ) -> Result<PackCandidate, String> {
        candidate_with_content(seed, relevance, utility, tokens, format!("memory {seed}"))
    }

    fn candidate_with_content(
        seed: u128,
        relevance: f32,
        utility: f32,
        tokens: u32,
        content: impl Into<String>,
    ) -> Result<PackCandidate, String> {
        PackCandidate::new(PackCandidateInput {
            memory_id: memory_id(seed),
            section: PackSection::ProceduralRules,
            content: content.into(),
            estimated_tokens: tokens,
            relevance: score(relevance)?,
            utility: score(utility)?,
            provenance: vec![provenance("file://AGENTS.md#L1")?],
            why: format!("selected because memory {seed} matches the task"),
        })
        .map_err(|error| format!("test candidate rejected: {error:?}"))
    }

    /// Classic-selector options: LOD compressed tiers default ON
    /// (lod_budget_shares 70/20/10), which changes quota, omission, and
    /// evaluation semantics. Tests that pin the CLASSIC selector contract
    /// must opt out explicitly instead of inheriting the LOD default.
    fn classic_pack_options() -> PackAssemblyOptions {
        PackAssemblyOptions {
            lod_budget_shares: None,
            ..PackAssemblyOptions::default()
        }
    }

    fn assemble_classic_draft_with_profile(
        profile: ContextPackProfile,
        query: impl Into<String>,
        budget: TokenBudget,
        candidates: impl IntoIterator<Item = PackCandidate>,
    ) -> Result<PackDraft, PackValidationError> {
        assemble_draft_with_profile_and_options(
            profile,
            query,
            budget,
            candidates,
            classic_pack_options(),
        )
    }

    fn candidate_in_section(
        seed: u128,
        section: PackSection,
        relevance: f32,
        utility: f32,
        tokens: u32,
        content: impl Into<String>,
    ) -> Result<PackCandidate, String> {
        PackCandidate::new(PackCandidateInput {
            memory_id: memory_id(seed),
            section,
            content: content.into(),
            estimated_tokens: tokens,
            relevance: score(relevance)?,
            utility: score(utility)?,
            provenance: vec![provenance("file://AGENTS.md#L1")?],
            why: format!("selected because memory {seed} matches the task"),
        })
        .map_err(|error| format!("test candidate rejected: {error:?}"))
    }

    fn repeated_lod_content(prefix: &str, count: usize) -> String {
        (0..count)
            .map(|index| format!("{prefix}{index}"))
            .collect::<Vec<_>>()
            .join(" ")
    }

    fn selected_item_for_memory(
        draft: &PackDraft,
        memory_id: MemoryId,
    ) -> Result<&PackDraftItem, String> {
        draft
            .items
            .iter()
            .find(|item| item.memory_id == memory_id)
            .ok_or_else(|| format!("expected selected item for memory {memory_id}"))
    }

    #[test]
    fn contradiction_guard_updates_pack_accounting_and_clears_hash() -> TestResult {
        let candidates = vec![
            candidate_with_content(
                1,
                0.95,
                0.8,
                30,
                "network retries must retry transient failures exactly three times",
            )?,
            candidate_with_content(
                2,
                0.94,
                0.8,
                20,
                "network retries must never retry transient failures",
            )?,
            candidate_with_content(3, 0.7, 0.5, 10, "keep release notes concise")?,
        ];
        // Budget 300 so Balanced's 30% ProceduralRules quota (90 tokens)
        // admits the full 60-token fixture under BOTH the LOD default and
        // the classic selector: at budget 100 the quota is 30 and only one
        // candidate fits, which starves the guard accounting under test.
        // (The earlier "expected 3 at budget 100" baseline was refreshed in
        // a55ae417 during the broken-proof-lane window and never verified.)
        let mut draft = assemble_draft_with_profile(
            ContextPackProfile::Balanced,
            "network retry policy",
            TokenBudget::new(300).map_err(|error| format!("budget rejected: {error:?}"))?,
            candidates,
        )
        .map_err(|error| format!("draft assembly failed: {error:?}"))?;
        ensure_equal(&draft.items.len(), &3, "fixture selected all candidates")?;
        draft.hash = Some("stale_hash_before_guard".to_owned());
        let pre_guard_objective = draft.selection_audit.total_objective_value;
        let pre_guard_step_count = draft.selection_audit.steps.len();

        let suppressed = draft.apply_contradiction_guard(
            &[(memory_id(1).to_string(), memory_id(2).to_string())],
            false,
        );

        ensure_equal(&suppressed, &1, "one contradiction side suppressed")?;
        ensure_equal(&draft.items.len(), &2, "selected item count after guard")?;
        ensure_equal(&draft.omitted.len(), &1, "omitted item count after guard")?;
        ensure(
            draft
                .items
                .iter()
                .filter(|item| item.memory_id == memory_id(1) || item.memory_id == memory_id(2))
                .count()
                == 1,
            "pack retains exactly one side of the unresolved contradiction",
        )?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.reason),
            &Some(PackOmissionReason::ContradictionSuppressed),
            "omission reason",
        )?;
        let selected_token_sum = draft
            .items
            .iter()
            .map(|item| item.estimated_tokens)
            .sum::<u32>();
        ensure_equal(
            &draft.used_tokens,
            &selected_token_sum,
            "used token accounting",
        )?;
        ensure_equal(
            &draft.selection_audit.selected_count,
            &draft.items.len(),
            "audit selected count",
        )?;
        ensure_equal(
            &draft.selection_audit.omitted_count,
            &draft.omitted.len(),
            "audit omitted count",
        )?;
        ensure_equal(
            &draft.selection_audit.budget_used,
            &draft.used_tokens,
            "audit budget used",
        )?;
        ensure_equal(
            &draft.selection_audit.selected_items.len(),
            &draft.items.len(),
            "audit selected items",
        )?;
        ensure_equal(
            &draft.selection_audit.steps.len(),
            &draft.items.len(),
            "audit steps mirror guarded item set",
        )?;
        ensure(
            draft.selection_audit.steps.len() < pre_guard_step_count,
            "guard should remove the suppressed memory's audit step",
        )?;
        let selected_memory_ids = draft
            .items
            .iter()
            .map(|item| item.memory_id.to_string())
            .collect::<std::collections::BTreeSet<_>>();
        let step_memory_ids = draft
            .selection_audit
            .steps
            .iter()
            .map(|step| step.memory_id.to_string())
            .collect::<std::collections::BTreeSet<_>>();
        ensure_equal(
            &step_memory_ids,
            &selected_memory_ids,
            "audit steps should only reference guarded selected items",
        )?;
        let suppressed_memory_id = draft
            .omitted
            .first()
            .map(|omission| omission.memory_id)
            .ok_or_else(|| "expected suppressed omission".to_owned())?;
        ensure(
            !draft
                .selection_audit
                .steps
                .iter()
                .any(|step| step.memory_id == suppressed_memory_id),
            "suppressed memory must not retain a stale audit step",
        )?;
        let phase_by_memory = draft
            .items
            .iter()
            .map(|item| (item.memory_id.to_string(), item.selected_in))
            .collect::<std::collections::BTreeMap<_, _>>();
        let mut expected_objective = 0.0_f32;
        for step in &draft.selection_audit.steps {
            let selection_phase = phase_by_memory
                .get(&step.memory_id.to_string())
                .copied()
                .ok_or_else(|| {
                    format!("missing selected item for audit step {}", step.memory_id)
                })?;
            if super::selection_phase_contributes_to_objective(
                draft.selection_audit.objective,
                selection_phase,
            ) {
                expected_objective += step.marginal_gain.max(0.0);
            }
            ensure_close(
                step.objective_value,
                expected_objective,
                "guarded audit step cumulative objective",
            )?;
        }
        ensure_close(
            draft.selection_audit.total_objective_value,
            expected_objective,
            "guarded audit total objective",
        )?;
        ensure(
            draft.selection_audit.total_objective_value < pre_guard_objective,
            "guard should remove the suppressed memory contribution from total objective",
        )?;
        ensure_equal(&draft.hash, &None, "guard clears stale pack hash")?;
        Ok(())
    }

    #[test]
    fn pack_draft_scratch_reset_reuses_and_expands_capacity() -> TestResult {
        let mut scratch = super::PackDraftScratch::with_candidate_capacity(2);
        let selected = candidate(1, 0.9, 0.5, 10)?;
        let omitted_candidate = candidate(2, 0.8, 0.5, 10)?;
        scratch.items.push(PackDraftItem::from_selected_candidate(
            1,
            selected,
            Vec::new(),
            PackSelectionPhase::StrictMmr,
        ));
        scratch.omitted.push(super::PackOmission::from_candidate(
            &omitted_candidate,
            PackOmissionReason::TokenBudgetExceeded,
            None,
        ));
        scratch.steps.push(super::PackSelectionStep {
            rank: 1,
            memory_id: memory_id(1),
            marginal_gain: 0.5,
            objective_value: 0.5,
            token_cost: 10,
            feasible: true,
            covered_features: vec!["section:procedural_rules".to_owned()],
        });

        let item_capacity = scratch.items.capacity();
        let omission_capacity = scratch.omitted.capacity();
        let step_capacity = scratch.steps.capacity();
        scratch.reset_for_candidate_capacity(1);

        ensure_equal(&scratch.items.len(), &0, "items cleared")?;
        ensure_equal(&scratch.omitted.len(), &0, "omissions cleared")?;
        ensure_equal(&scratch.steps.len(), &0, "steps cleared")?;
        ensure(
            scratch.items.capacity() >= item_capacity,
            "item capacity should not shrink on reset",
        )?;
        ensure(
            scratch.omitted.capacity() >= omission_capacity,
            "omission capacity should not shrink on reset",
        )?;
        ensure(
            scratch.steps.capacity() >= step_capacity,
            "step capacity should not shrink on reset",
        )?;

        scratch.reset_for_candidate_capacity(8);
        ensure(
            scratch.items.capacity() >= 8,
            "item capacity should expand to requested candidate count",
        )?;
        ensure(
            scratch.omitted.capacity() >= 8,
            "omission capacity should expand to requested candidate count",
        )?;
        ensure(
            scratch.steps.capacity() >= 8,
            "step capacity should expand to requested candidate count",
        )
    }

    #[test]
    fn mmr_assembly_scratch_reset_reinitializes_similarity_slots() -> TestResult {
        let mut scratch = super::MmrAssemblyScratch::with_candidate_capacity(2);
        let candidate =
            candidate_with_content(1, 0.9, 0.5, 10, "Run cargo fmt --check before release.")?;
        scratch
            .selected_signatures
            .push(super::CandidateSignature::from(&candidate));
        scratch
            .coverage_fill_candidates
            .push(super::MmrCandidate::from(candidate));
        scratch.max_selected_similarities[0] = 0.95;
        let selected_capacity = scratch.selected_signatures.capacity();
        let fill_capacity = scratch.coverage_fill_candidates.capacity();

        scratch.reset_for_candidate_capacity(4);

        ensure_equal(
            &scratch.selected_signatures.len(),
            &0,
            "selected signatures cleared",
        )?;
        ensure_equal(
            &scratch.coverage_fill_candidates.len(),
            &0,
            "coverage-fill candidates cleared",
        )?;
        ensure_equal(
            &scratch.max_selected_similarities.len(),
            &4,
            "similarity slot count reset",
        )?;
        ensure(
            scratch
                .max_selected_similarities
                .iter()
                .all(|similarity| *similarity == 0.0),
            "similarity slots reset to zero",
        )?;
        ensure(
            scratch.selected_signatures.capacity() >= selected_capacity,
            "selected signature capacity should not shrink on reset",
        )?;
        ensure(
            scratch.coverage_fill_candidates.capacity() >= fill_capacity,
            "coverage-fill capacity should not shrink on reset",
        )?;
        ensure(
            scratch.max_selected_similarities.capacity() >= 4,
            "similarity capacity should expand to requested candidate count",
        )
    }

    #[test]
    fn pack_assembly_scratch_adapter_keeps_large_inputs_deterministic() -> TestResult {
        let candidate_count = 64_usize;
        let candidates = facility_benchmark_candidates(candidate_count)?;
        let budget =
            TokenBudget::new(10_000).map_err(|error| format!("budget rejected: {error:?}"))?;

        let first_mmr = assemble_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates.clone(),
        )
        .map_err(|error| format!("first mmr draft rejected: {error:?}"))?;
        let second_mmr = assemble_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates.clone(),
        )
        .map_err(|error| format!("second mmr draft rejected: {error:?}"))?;
        ensure_equal(
            &first_mmr.selection_audit.selected_items,
            &second_mmr.selection_audit.selected_items,
            "MMR selected item order remains deterministic",
        )?;
        ensure_equal(
            &first_mmr.selection_audit.candidate_count,
            &candidate_count,
            "MMR candidate count",
        )?;

        let first_facility = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            candidates.clone(),
        )
        .map_err(|error| format!("first facility draft rejected: {error:?}"))?;
        let second_facility = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            candidates,
        )
        .map_err(|error| format!("second facility draft rejected: {error:?}"))?;
        ensure_equal(
            &first_facility.selection_audit.selected_items,
            &second_facility.selection_audit.selected_items,
            "facility selected item order remains deterministic",
        )?;
        ensure_equal(
            &first_facility.selection_audit.candidate_count,
            &candidate_count,
            "facility candidate count",
        )
    }

    #[test]
    fn arena_mode_default_is_disabled() -> TestResult {
        ensure_equal(
            &super::PackAssemblyOptions::default().arena_mode,
            &super::ArenaMode::Disabled,
            "PackAssemblyOptions::default() must keep arena disabled \
             so existing public output is unchanged",
        )?;
        ensure_equal(
            &super::ArenaMode::default(),
            &super::ArenaMode::Disabled,
            "ArenaMode::default() must be Disabled",
        )
    }

    #[test]
    fn arena_mode_as_str_uses_stable_wire_names() -> TestResult {
        ensure_equal(
            &super::ArenaMode::Disabled.as_str(),
            &"disabled",
            "Disabled wire-name must remain stable for tracing/perf consumers",
        )?;
        ensure_equal(
            &super::ArenaMode::RequestScoped.as_str(),
            &"request_scoped",
            "RequestScoped wire-name must remain stable for tracing/perf consumers",
        )?;
        ensure_equal(
            &super::ArenaMode::WorkspaceReuse.as_str(),
            &"workspace_reuse",
            "WorkspaceReuse wire-name must remain stable for tracing/perf consumers",
        )
    }

    fn arena_workspace() -> PackArenaWorkspace {
        PackArenaWorkspace::new(PackArenaWorkspaceKey::new(
            "file:///tmp/ee-arena-test-workspace",
            PackResourceProfile::Standard,
        ))
    }

    // bd-1prrl.7.3 parity goldens: arena mode is an internal allocation
    // strategy and must never change public pack output. The contract in
    // docs/pack-arena-assembly.md enumerates the parity surfaces; these
    // tests freeze the byte-identical contract on MMR, facility-location,
    // and empty paths so bd-1prrl.7.4's broader golden harness can layer
    // on top without re-establishing the basic invariant.

    fn assert_packs_equal_across_arena_mode(
        a: &PackDraft,
        b: &PackDraft,
        label: &str,
    ) -> TestResult {
        ensure_equal(
            &a.items,
            &b.items,
            &format!("{label}: items must match across arena modes"),
        )?;
        ensure_equal(
            &a.omitted,
            &b.omitted,
            &format!("{label}: omissions must match across arena modes"),
        )?;
        ensure_equal(
            &a.used_tokens,
            &b.used_tokens,
            &format!("{label}: used_tokens must match across arena modes"),
        )?;
        ensure_equal(
            &a.budget,
            &b.budget,
            &format!("{label}: budget must match across arena modes"),
        )?;
        ensure_equal(
            &a.selection_audit.selected_items,
            &b.selection_audit.selected_items,
            &format!("{label}: selection audit items must match"),
        )?;
        ensure_equal(
            &a.selection_audit.steps,
            &b.selection_audit.steps,
            &format!("{label}: selection audit steps must match"),
        )?;
        ensure_equal(
            &a.selection_audit.candidate_count,
            &b.selection_audit.candidate_count,
            &format!("{label}: selection audit candidate_count must match"),
        )?;
        ensure_equal(
            &a.selection_audit.algorithm_id,
            &b.selection_audit.algorithm_id,
            &format!("{label}: algorithm_id must match"),
        )
    }

    #[test]
    fn arena_mode_parity_mmr_balanced() -> TestResult {
        let candidates = facility_benchmark_candidates(48)?;
        let budget =
            TokenBudget::new(4_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let determinism = Deterministic::from_seed(0xee_a7_e3_3a);
        let disabled = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::Disabled,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("disabled draft rejected: {error:?}"))?;
        let request_scoped = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates,
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::RequestScoped,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("request_scoped draft rejected: {error:?}"))?;
        assert_packs_equal_across_arena_mode(&disabled, &request_scoped, "mmr_balanced")
    }

    #[test]
    fn arena_mode_workspace_reuse_mmr_balanced_matches_disabled_and_reuses_scratch() -> TestResult {
        let candidates = facility_benchmark_candidates(48)?;
        let budget =
            TokenBudget::new(4_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let determinism = Deterministic::from_seed(0xee_a7_e3_3a);
        let disabled = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::Disabled,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("disabled draft rejected: {error:?}"))?;
        let mut workspace = arena_workspace();
        let first = assemble_draft_with_profile_and_options_seeded_in_workspace(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::WorkspaceReuse,
                ..PackAssemblyOptions::default()
            },
            &determinism,
            &mut workspace,
        )
        .map_err(|error| format!("workspace_reuse first draft rejected: {error:?}"))?;
        let second = assemble_draft_with_profile_and_options_seeded_in_workspace(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates,
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::WorkspaceReuse,
                ..PackAssemblyOptions::default()
            },
            &determinism,
            &mut workspace,
        )
        .map_err(|error| format!("workspace_reuse second draft rejected: {error:?}"))?;

        assert_packs_equal_across_arena_mode(&disabled, &first, "workspace_reuse_mmr_first")?;
        assert_packs_equal_across_arena_mode(&disabled, &second, "workspace_reuse_mmr_second")?;
        let stats = workspace.stats();
        ensure_equal(
            &stats.fresh_scratch_allocations,
            &1,
            "workspace reuse should allocate the MMR scratch once",
        )?;
        ensure(
            stats.reset_count >= 1,
            "workspace reuse should reset scratch for the second request",
        )?;
        ensure(
            !stats.poisoned,
            "workspace reuse should remain unpoisoned for normal MMR requests",
        )
    }

    #[test]
    fn arena_workspace_reuse_empty_query_preserves_cached_mmr_scratch() -> TestResult {
        let candidates = facility_benchmark_candidates(12)?;
        let budget =
            TokenBudget::new(4_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let determinism = Deterministic::from_seed(0xee_a7_e3_3a);
        let mut workspace = arena_workspace();

        assemble_draft_with_profile_and_options_seeded_in_workspace(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::WorkspaceReuse,
                ..PackAssemblyOptions::default()
            },
            &determinism,
            &mut workspace,
        )
        .map_err(|error| format!("workspace_reuse warmup draft rejected: {error:?}"))?;
        let after_warmup = workspace.stats();
        ensure_equal(
            &after_warmup.fresh_scratch_allocations,
            &1,
            "workspace reuse should cache one MMR scratch after warmup",
        )?;

        let empty_query = assemble_draft_with_profile_and_options_seeded_in_workspace(
            ContextPackProfile::Balanced,
            " ",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::WorkspaceReuse,
                ..PackAssemblyOptions::default()
            },
            &determinism,
            &mut workspace,
        );
        ensure(
            matches!(empty_query, Err(PackValidationError::EmptyQuery)),
            "empty workspace-reuse query must be rejected",
        )?;
        let after_error = workspace.stats();
        ensure_equal(
            &after_error.fresh_scratch_allocations,
            &after_warmup.fresh_scratch_allocations,
            "validation errors must not drop cached MMR scratch",
        )?;

        assemble_draft_with_profile_and_options_seeded_in_workspace(
            ContextPackProfile::Balanced,
            "ship arena parity",
            budget,
            candidates,
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::WorkspaceReuse,
                ..PackAssemblyOptions::default()
            },
            &determinism,
            &mut workspace,
        )
        .map_err(|error| format!("workspace_reuse post-error draft rejected: {error:?}"))?;
        let after_second_success = workspace.stats();
        ensure_equal(
            &after_second_success.fresh_scratch_allocations,
            &1,
            "post-error request should reuse cached MMR scratch instead of allocating again",
        )
    }

    #[test]
    fn arena_mode_parity_facility_location_submodular() -> TestResult {
        let candidates = facility_benchmark_candidates(48)?;
        let budget =
            TokenBudget::new(4_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let determinism = Deterministic::from_seed(0xfa_c1_77_07);
        let disabled = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Submodular,
            "ship arena parity",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::Disabled,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("disabled draft rejected: {error:?}"))?;
        let request_scoped = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Submodular,
            "ship arena parity",
            budget,
            candidates,
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::RequestScoped,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("request_scoped draft rejected: {error:?}"))?;
        assert_packs_equal_across_arena_mode(
            &disabled,
            &request_scoped,
            "facility_location_submodular",
        )
    }

    #[test]
    fn arena_mode_workspace_reuse_facility_location_matches_disabled() -> TestResult {
        let candidates = facility_benchmark_candidates(48)?;
        let budget =
            TokenBudget::new(4_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let determinism = Deterministic::from_seed(0xfa_c1_77_07);
        let disabled = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Submodular,
            "ship arena parity",
            budget,
            candidates.clone(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::Disabled,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("disabled draft rejected: {error:?}"))?;
        let mut workspace = arena_workspace();
        let workspace_reuse = assemble_draft_with_profile_and_options_seeded_in_workspace(
            ContextPackProfile::Submodular,
            "ship arena parity",
            budget,
            candidates,
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::WorkspaceReuse,
                ..PackAssemblyOptions::default()
            },
            &determinism,
            &mut workspace,
        )
        .map_err(|error| format!("workspace_reuse draft rejected: {error:?}"))?;
        assert_packs_equal_across_arena_mode(
            &disabled,
            &workspace_reuse,
            "workspace_reuse_facility_location_submodular",
        )
    }

    #[test]
    fn arena_mode_parity_empty_candidate_pool() -> TestResult {
        let budget = TokenBudget::new(1_000).map_err(|error| format!("budget: {error:?}"))?;
        let determinism = Deterministic::from_seed(0);
        let disabled = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Balanced,
            "empty arena parity",
            budget,
            Vec::<PackCandidate>::new(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::Disabled,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("disabled draft rejected: {error:?}"))?;
        let request_scoped = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Balanced,
            "empty arena parity",
            budget,
            Vec::<PackCandidate>::new(),
            PackAssemblyOptions {
                arena_mode: super::ArenaMode::RequestScoped,
                ..PackAssemblyOptions::default()
            },
            &determinism,
        )
        .map_err(|error| format!("request_scoped draft rejected: {error:?}"))?;
        ensure(
            disabled.items.is_empty() && request_scoped.items.is_empty(),
            "empty candidate pool must produce empty items in both arena modes",
        )?;
        assert_packs_equal_across_arena_mode(&disabled, &request_scoped, "empty_pool_balanced")
    }

    fn draft_from_candidates(candidates: Vec<PackCandidate>) -> Result<PackDraft, String> {
        let budget = TokenBudget::new(1_000).map_err(|error| format!("budget: {error:?}"))?;
        let mut used_tokens = 0_u32;
        let candidate_count = candidates.len();
        let mut selected_items = Vec::new();
        let mut items = Vec::new();
        for (index, candidate) in candidates.into_iter().enumerate() {
            used_tokens = used_tokens.saturating_add(candidate.estimated_tokens);
            let rank = u32::try_from(index + 1).unwrap_or(u32::MAX);
            selected_items.push(PackSelectedItem {
                rank,
                memory_id: candidate.memory_id,
                token_cost: candidate.estimated_tokens,
                feasible: true,
            });
            items.push(PackDraftItem::from_selected_candidate(
                rank,
                candidate,
                Vec::new(),
                PackSelectionPhase::StrictMmr,
            ));
        }

        Ok(PackDraft {
            query: "test pack ordering".to_owned(),
            budget,
            used_tokens,
            items,
            evidence_items: Vec::new(),
            omitted: Vec::new(),
            selection_audit: PackSelectionAudit {
                profile: ContextPackProfile::Balanced,
                objective: PackSelectionObjective::MmrRedundancy,
                algorithm_id: "test",
                algorithm_description: "test selection audit",
                candidate_count,
                selected_count: selected_items.len(),
                omitted_count: 0,
                budget_limit: 1_000,
                budget_used: used_tokens,
                total_objective_value: 0.0,
                monotone: false,
                submodular: false,
                selected_items,
                steps: Vec::new(),
            },
            hash: None,
        })
    }

    fn facility_benchmark_candidates(count: usize) -> Result<Vec<PackCandidate>, String> {
        (0..count)
            .map(|index| {
                let seed = (index as u128).saturating_add(1);
                let relevance = 1.0 - ((index as f32) * 0.000_1);
                candidate_with_content(
                    seed,
                    relevance.max(0.1),
                    0.5,
                    10,
                    format!("facility unique token alpha{index} beta{index} gamma{index}"),
                )
            })
            .collect()
    }

    fn exhaustive_facility_candidate_index(
        remaining_indices: &[usize],
        universe: &[super::FacilityCandidateProfile],
        current_coverages: &[f32],
        used_tokens: u32,
        budget: TokenBudget,
        quotas: &SectionQuotas,
        section_usage: &super::SectionTokenUsage,
    ) -> Option<(usize, f32)> {
        let mut best: Option<(usize, usize, f32, f32)> = None;

        for (candidate_index, &profile_index) in remaining_indices.iter().enumerate() {
            let Some(profile) = universe.get(profile_index) else {
                continue;
            };
            let Some(candidate) = profile.candidate.as_ref() else {
                continue;
            };
            if !super::facility_candidate_is_feasible(
                candidate,
                used_tokens,
                budget,
                quotas,
                section_usage,
            ) {
                continue;
            }

            let marginal_gain = super::facility_marginal_gain(profile, universe, current_coverages);
            let gain_ratio = marginal_gain / candidate.estimated_tokens as f32;
            match best {
                None => best = Some((candidate_index, profile_index, marginal_gain, gain_ratio)),
                Some((_, best_profile_index, best_gain, best_ratio)) => {
                    let Some(best_candidate) = universe
                        .get(best_profile_index)
                        .and_then(|profile| profile.candidate.as_ref())
                    else {
                        continue;
                    };
                    if gain_ratio
                        .total_cmp(&best_ratio)
                        .then_with(|| marginal_gain.total_cmp(&best_gain))
                        .then_with(|| super::compare_candidates(best_candidate, candidate))
                        == std::cmp::Ordering::Greater
                    {
                        best = Some((candidate_index, profile_index, marginal_gain, gain_ratio));
                    }
                }
            }
        }

        best.map(|(candidate_index, _, marginal_gain, _)| (candidate_index, marginal_gain))
    }

    fn run_exhaustive_facility_selection(
        candidates: Vec<PackCandidate>,
        budget: TokenBudget,
    ) -> Result<Vec<MemoryId>, String> {
        let mut candidates = candidates;
        candidates.sort_by(super::compare_candidates);
        let mut universe: Vec<super::FacilityCandidateProfile> = candidates
            .into_iter()
            .map(super::FacilityCandidateProfile::from)
            .collect();
        let mut remaining_indices: Vec<usize> = (0..universe.len()).collect();
        let mut current_coverages = vec![0.0_f32; universe.len()];
        let similarity_cache = super::FacilitySimilarityCache::new(&universe);
        let quotas =
            SectionQuotas::for_profile(ContextPackProfile::Submodular, budget.max_tokens());
        let mut used_tokens = 0_u32;
        let mut section_usage = super::SectionTokenUsage::default();
        let mut selected = Vec::new();

        while !remaining_indices.is_empty() {
            let Some((candidate_index, marginal_gain)) = exhaustive_facility_candidate_index(
                &remaining_indices,
                &universe,
                &current_coverages,
                used_tokens,
                budget,
                &quotas,
                &section_usage,
            ) else {
                break;
            };
            if marginal_gain <= super::FACILITY_LOCATION_EPSILON {
                break;
            }
            let profile_index = remaining_indices.remove(candidate_index);
            let Some(profile) = universe.get_mut(profile_index) else {
                continue;
            };
            let Some(candidate) = profile.candidate.take() else {
                continue;
            };
            used_tokens = used_tokens.saturating_add(candidate.estimated_tokens);
            section_usage.add_candidate(&candidate);
            selected.push(candidate.memory_id);
            super::update_facility_coverages_cached(
                &universe,
                &mut current_coverages,
                &similarity_cache,
                profile_index,
            );
        }

        Ok(selected)
    }

    #[test]
    fn subsystem_name_is_stable() -> TestResult {
        ensure_equal(&subsystem_name(), &"pack", "subsystem name")
    }

    #[test]
    fn default_chars_per_token_is_conservative() -> TestResult {
        ensure(
            DEFAULT_CHARS_PER_TOKEN < 4.0,
            "default ratio should be below 4.0 for conservative estimation",
        )?;
        ensure(
            DEFAULT_CHARS_PER_TOKEN > 2.0,
            "default ratio should be above 2.0 to avoid extreme overestimation",
        )
    }

    #[test]
    fn token_estimation_strategy_strings_are_stable() -> TestResult {
        ensure_equal(
            &TokenEstimationStrategy::TiktokenCl100kBase.as_str(),
            &"tiktoken_cl100k_base",
            "tiktoken cl100k_base strategy",
        )?;
        ensure_equal(
            &TokenEstimationStrategy::CharacterHeuristic.as_str(),
            &"character_heuristic",
            "character heuristic strategy",
        )?;
        ensure_equal(
            &TokenEstimationStrategy::WordHeuristic.as_str(),
            &"word_heuristic",
            "word heuristic strategy",
        )?;
        ensure_equal(
            &TokenEstimationStrategy::all().len(),
            &3,
            "all strategies count",
        )?;
        ensure_equal(
            &TokenEstimationStrategy::default(),
            &TokenEstimationStrategy::TiktokenCl100kBase,
            "default strategy is tiktoken cl100k_base",
        )
    }

    #[test]
    fn estimate_tokens_returns_zero_for_empty_input() -> TestResult {
        ensure_equal(
            &estimate_tokens("", TokenEstimationStrategy::CharacterHeuristic),
            &0,
            "empty string",
        )?;
        ensure_equal(
            &estimate_tokens("   ", TokenEstimationStrategy::CharacterHeuristic),
            &0,
            "whitespace only",
        )?;
        ensure_equal(
            &estimate_tokens("\n\t", TokenEstimationStrategy::WordHeuristic),
            &0,
            "whitespace with word heuristic",
        )
    }

    #[test]
    fn estimate_tokens_returns_at_least_one_for_non_empty() -> TestResult {
        ensure(
            estimate_tokens("x", TokenEstimationStrategy::CharacterHeuristic) >= 1,
            "single char should estimate at least 1 token",
        )?;
        ensure(
            estimate_tokens("word", TokenEstimationStrategy::WordHeuristic) >= 1,
            "single word should estimate at least 1 token",
        )
    }

    #[test]
    fn estimate_tokens_character_heuristic_saturates_explicitly() -> TestResult {
        ensure_equal(
            &estimate_character_heuristic_tokens(7),
            &2,
            "7 chars at 3.5 chars/token",
        )?;
        ensure_equal(
            &estimate_character_heuristic_tokens(11),
            &4,
            "11 chars at 3.5 chars/token",
        )?;

        let first_overflowing_char_count = (u64::from(u32::MAX)
            * CHARACTER_HEURISTIC_CHARS_PER_TOKEN_NUMERATOR
            / CHARACTER_HEURISTIC_CHARS_PER_TOKEN_DENOMINATOR)
            + 1;
        ensure_equal(
            &estimate_character_heuristic_tokens(first_overflowing_char_count),
            &u32::MAX,
            "huge character counts saturate explicitly at u32::MAX",
        )
    }

    #[test]
    fn estimate_tokens_word_heuristic_saturates_explicitly() -> TestResult {
        ensure_equal(
            &estimate_word_heuristic_tokens(5),
            &7,
            "5 words at 1.3 tokens/word",
        )?;

        let first_overflowing_word_count = (u64::from(u32::MAX)
            * WORD_HEURISTIC_TOKEN_MULTIPLIER_DENOMINATOR
            / WORD_HEURISTIC_TOKEN_MULTIPLIER_NUMERATOR)
            + 1;
        ensure_equal(
            &estimate_word_heuristic_tokens(first_overflowing_word_count),
            &u32::MAX,
            "huge word counts saturate explicitly at u32::MAX",
        )
    }

    #[test]
    fn estimate_tokens_character_heuristic_is_deterministic() -> TestResult {
        let content = "This is a test string for token estimation.";
        let first = estimate_tokens(content, TokenEstimationStrategy::CharacterHeuristic);
        let second = estimate_tokens(content, TokenEstimationStrategy::CharacterHeuristic);
        ensure_equal(&first, &second, "deterministic estimation")
    }

    #[test]
    fn estimate_tokens_character_heuristic_scales_with_length() -> TestResult {
        let short = estimate_tokens("hello", TokenEstimationStrategy::CharacterHeuristic);
        let long = estimate_tokens(
            "hello world this is a much longer string",
            TokenEstimationStrategy::CharacterHeuristic,
        );
        ensure(long > short, "longer content should estimate more tokens")
    }

    #[test]
    fn estimate_tokens_word_heuristic_counts_words() -> TestResult {
        let one_word = estimate_tokens("hello", TokenEstimationStrategy::WordHeuristic);
        let five_words = estimate_tokens(
            "one two three four five",
            TokenEstimationStrategy::WordHeuristic,
        );
        ensure(
            five_words > one_word,
            "more words should estimate more tokens",
        )?;
        ensure(
            five_words >= 5,
            "five words should estimate at least 5 tokens (with 1.3 multiplier)",
        )
    }

    #[test]
    fn estimate_tokens_default_uses_tiktoken_cl100k_base() -> TestResult {
        let content = "test content";
        let default_result = estimate_tokens_default(content);
        let explicit_result = estimate_tokens(content, TokenEstimationStrategy::TiktokenCl100kBase);
        ensure_equal(
            &default_result,
            &explicit_result,
            "default matches tiktoken cl100k_base",
        )
    }

    /// eidetic_engine_cli-aitk: real BPE counts must match what GPT-3.5/4
    /// would actually see, not the character-ratio heuristic. These three
    /// short strings have well-known cl100k_base token counts.
    #[test]
    fn estimate_tokens_tiktoken_matches_known_short_strings() -> TestResult {
        // "hello world" tokenizes as ["hello", " world"] under cl100k_base
        // — exactly 2 tokens.
        ensure_equal(
            &estimate_tokens("hello world", TokenEstimationStrategy::TiktokenCl100kBase),
            &2,
            "hello world is 2 cl100k_base tokens",
        )?;
        // A single ASCII letter is 1 token.
        ensure_equal(
            &estimate_tokens("a", TokenEstimationStrategy::TiktokenCl100kBase),
            &1,
            "single letter is 1 cl100k_base token",
        )?;
        // Empty string still returns 0 (consistent with the heuristic
        // strategies' early-return contract).
        ensure_equal(
            &estimate_tokens("", TokenEstimationStrategy::TiktokenCl100kBase),
            &0,
            "empty string is 0 cl100k_base tokens",
        )?;
        // Whitespace-only strings are trimmed away first.
        ensure_equal(
            &estimate_tokens("   \n\t", TokenEstimationStrategy::TiktokenCl100kBase),
            &0,
            "whitespace trims to 0 tokens",
        )
    }

    /// eidetic_engine_cli-aitk: the original bug noted that CJK content
    /// tokenizes at ~1 token/char in cl100k while the character heuristic
    /// undercounts it ~3.5x. This test pins the actual ratio so a future
    /// regression doesn't quietly drift back to the heuristic.
    #[test]
    fn estimate_tokens_tiktoken_is_more_accurate_than_heuristic_for_cjk() -> TestResult {
        let cjk = "你好世界你好世界你好世界你好世界"; // 16 CJK chars
        let tiktoken = estimate_tokens(cjk, TokenEstimationStrategy::TiktokenCl100kBase);
        let character = estimate_tokens(cjk, TokenEstimationStrategy::CharacterHeuristic);
        ensure(
            tiktoken > character,
            "tiktoken should count CJK higher than the chars/3.5 heuristic does",
        )?;
        // 16 chars / 3.5 = 5; cl100k_base typically lands around 16-32 for
        // this kind of content. Lower bound is conservative.
        ensure(
            tiktoken >= 8,
            "16 CJK chars should round to at least 8 cl100k_base tokens",
        )
    }

    /// eidetic_engine_cli-aitk: tiktoken counting must be deterministic
    /// across calls, since context pack hashes are part of the
    /// reproducibility contract.
    #[test]
    fn estimate_tokens_tiktoken_is_deterministic() -> TestResult {
        let content = "Procedural rule: run cargo fmt --check before release.";
        let first = estimate_tokens(content, TokenEstimationStrategy::TiktokenCl100kBase);
        let second = estimate_tokens(content, TokenEstimationStrategy::TiktokenCl100kBase);
        ensure_equal(&first, &second, "tiktoken estimation must be deterministic")
    }

    #[test]
    fn estimate_tokens_trims_input_before_counting() -> TestResult {
        let clean = estimate_tokens("hello world", TokenEstimationStrategy::CharacterHeuristic);
        let padded = estimate_tokens(
            "  hello world  ",
            TokenEstimationStrategy::CharacterHeuristic,
        );
        ensure_equal(&clean, &padded, "trimmed content should match")
    }

    #[test]
    fn estimate_tokens_handles_unicode_characters() -> TestResult {
        // Multi-byte UTF-8: each emoji is 1 char but 4 bytes
        let emoji = "🦀🔥💻";
        let emoji_tokens = estimate_tokens(emoji, TokenEstimationStrategy::CharacterHeuristic);
        ensure(
            emoji_tokens >= 1,
            "emoji string should estimate at least 1 token",
        )?;
        // 3 emoji chars / 3.5 chars per token = ~1 token
        ensure(
            emoji_tokens <= 3,
            "3 emoji should not overestimate drastically",
        )?;

        // CJK characters: each is 1 char but 3 bytes
        let cjk = "你好世界";
        let cjk_tokens = estimate_tokens(cjk, TokenEstimationStrategy::CharacterHeuristic);
        ensure(
            cjk_tokens >= 1,
            "CJK string should estimate at least 1 token",
        )?;
        // 4 CJK chars / 3.5 = ~2 tokens
        ensure(
            cjk_tokens <= 4,
            "4 CJK chars should not overestimate drastically",
        )?;

        // Mixed ASCII and Unicode
        let mixed = "Hello 世界! 🦀";
        let mixed_tokens = estimate_tokens(mixed, TokenEstimationStrategy::CharacterHeuristic);
        ensure(
            mixed_tokens >= 1,
            "mixed content should estimate at least 1 token",
        )?;

        Ok(())
    }

    #[test]
    fn estimate_tokens_unicode_is_deterministic() -> TestResult {
        let unicode_content = "Ümläüts, émojis 🎉, and CJK 中文字符";
        let first = estimate_tokens(unicode_content, TokenEstimationStrategy::CharacterHeuristic);
        let second = estimate_tokens(unicode_content, TokenEstimationStrategy::CharacterHeuristic);
        ensure_equal(&first, &second, "Unicode estimation must be deterministic")
    }

    #[test]
    fn estimate_tokens_word_heuristic_handles_unicode_words() -> TestResult {
        // Word heuristic should count whitespace-separated words regardless of script
        let mixed_words = "Hello 世界 Bonjour мир";
        let token_count = estimate_tokens(mixed_words, TokenEstimationStrategy::WordHeuristic);
        // 4 words * 1.3 = 5.2, ceil = 6
        ensure(
            token_count >= 4,
            "4 Unicode words should estimate at least 4 tokens",
        )?;
        ensure(
            token_count <= 8,
            "4 Unicode words should not overestimate beyond reason",
        )
    }

    // ------------------------------------------------------------------
    // EE-57vk: deeper Unicode edge-case coverage for estimate_tokens
    //
    // The earlier tests cover plain emoji, CJK, and basic combining
    // marks. These additions stress the codepoint-counting contract
    // against grapheme-level subtleties (ZWJ family sequences, RTL,
    // multi-codepoint combining marks, BMP/non-BMP boundaries) plus
    // protocol-level oddities (BOM, embedded NUL) that have historically
    // tripped up character-counting heuristics in other tools.
    //
    // All assertions stay coarse (>= / <=) on purpose: the heuristic
    // intentionally overestimates and we want the tests to keep passing
    // if the multiplier is tuned, but flag any catastrophic drift.
    // ------------------------------------------------------------------

    #[test]
    fn estimate_tokens_zwj_emoji_sequence_counts_each_codepoint() -> TestResult {
        // 👨‍👩‍👧‍👦 = man + ZWJ + woman + ZWJ + girl + ZWJ + boy = 7 codepoints,
        // rendered as a single grapheme cluster. Rust's `chars().count()`
        // counts codepoints, not graphemes — pin that contract so a switch
        // to grapheme-level counting (which would slash the estimate) is a
        // visible change and not a silent regression.
        let family = "👨\u{200D}👩\u{200D}👧\u{200D}👦";
        ensure_equal(&family.chars().count(), &7, "expected 7 codepoints")?;

        let tokens = estimate_tokens(family, TokenEstimationStrategy::CharacterHeuristic);
        // 7 codepoints / 3.5 cpt = 2 tokens exactly
        ensure_equal(&tokens, &2, "ZWJ family sequence character-heuristic")?;

        let word_tokens = estimate_tokens(family, TokenEstimationStrategy::WordHeuristic);
        ensure_equal(
            &word_tokens,
            &2,
            "ZWJ family is a single word: ceil(1*1.3) = 2",
        )
    }

    #[test]
    fn estimate_tokens_rtl_text_matches_codepoint_count() -> TestResult {
        // Hebrew "shalom" — 6 codepoints, no whitespace, RTL directionality
        // is a renderer concern only and must not affect estimation.
        let hebrew = "שלום!";
        ensure_equal(&hebrew.chars().count(), &5, "expected 5 codepoints")?;
        let tokens = estimate_tokens(hebrew, TokenEstimationStrategy::CharacterHeuristic);
        // ceil(5 / 3.5) = 2
        ensure_equal(&tokens, &2, "RTL token estimate")?;

        // Arabic with explicit RTL marks should still be counted by codepoint
        let arabic_with_marks = "\u{202E}مرحبا\u{202C}";
        ensure(
            estimate_tokens(
                arabic_with_marks,
                TokenEstimationStrategy::CharacterHeuristic,
            ) >= 1,
            "Arabic with directional marks should estimate >= 1 token",
        )
    }

    #[test]
    fn estimate_tokens_combining_marks_counted_per_codepoint() -> TestResult {
        // NFD form of "café" = c + a + f + e + COMBINING ACUTE = 5 codepoints
        // NFC form = c + a + f + é = 4 codepoints. The two normalize to the
        // same grapheme but produce different estimates by design.
        let nfc = "caf\u{00E9}";
        let nfd = "cafe\u{0301}";
        ensure_equal(&nfc.chars().count(), &4, "NFC codepoints")?;
        ensure_equal(&nfd.chars().count(), &5, "NFD codepoints")?;

        let nfc_tokens = estimate_tokens(nfc, TokenEstimationStrategy::CharacterHeuristic);
        let nfd_tokens = estimate_tokens(nfd, TokenEstimationStrategy::CharacterHeuristic);
        ensure(
            nfd_tokens >= nfc_tokens,
            format!("NFD must not under-count vs NFC: nfc={nfc_tokens} nfd={nfd_tokens}"),
        )
    }

    #[test]
    fn estimate_tokens_handles_supplementary_plane_codepoints() -> TestResult {
        // Each of these is a single Rust char even though they are encoded
        // as a surrogate pair in UTF-16 and four bytes in UTF-8. Rust strings
        // are always valid UTF-8 with no naked surrogates, so the test pins
        // that boundary handling stays codepoint-based.
        let smp = "𝐇𝐞𝐥𝐥𝐨"; // Mathematical bold Hello, U+1D400-U+1D4xx range
        ensure_equal(&smp.chars().count(), &5, "5 SMP codepoints")?;
        ensure_equal(&smp.len(), &20, "5 codepoints x 4 bytes each")?;

        let tokens = estimate_tokens(smp, TokenEstimationStrategy::CharacterHeuristic);
        // ceil(5/3.5) = 2
        ensure_equal(&tokens, &2, "supplementary-plane token estimate")
    }

    #[test]
    fn estimate_tokens_strips_leading_byte_order_mark() -> TestResult {
        // BOM (U+FEFF) is treated as a zero-width no-break space and does
        // NOT match `char::is_whitespace`, so `str::trim` does not strip
        // it. That means a leading BOM contributes one codepoint to the
        // estimate. Pin the current behavior so any switch to bom-stripping
        // is an intentional, visible change.
        let with_bom = "\u{FEFF}hello";
        let without_bom = "hello";
        let with = estimate_tokens(with_bom, TokenEstimationStrategy::CharacterHeuristic);
        let without = estimate_tokens(without_bom, TokenEstimationStrategy::CharacterHeuristic);
        ensure(
            with >= without,
            format!("BOM must not under-count: with={with} without={without}"),
        )?;
        // Word heuristic: BOM glues to "hello" (no whitespace) so still 1 word
        let with_word = estimate_tokens(with_bom, TokenEstimationStrategy::WordHeuristic);
        ensure_equal(
            &with_word,
            &2,
            "BOM + word still counts as 1 word -> 2 tokens",
        )
    }

    #[test]
    fn estimate_tokens_handles_embedded_nul_byte() -> TestResult {
        // Rust strings can carry NUL codepoints. We must (a) not panic and
        // (b) count the NUL as one codepoint in the character heuristic and
        // as content for the word heuristic.
        let with_nul = "hello\u{0000}world";
        ensure_equal(&with_nul.chars().count(), &11, "NUL counts as 1 codepoint")?;

        let char_tokens = estimate_tokens(with_nul, TokenEstimationStrategy::CharacterHeuristic);
        // ceil(11/3.5) = 4
        ensure_equal(&char_tokens, &4, "NUL char-heuristic")?;

        let word_tokens = estimate_tokens(with_nul, TokenEstimationStrategy::WordHeuristic);
        // No whitespace -> 1 word -> ceil(1.3) = 2
        ensure_equal(&word_tokens, &2, "NUL word-heuristic")
    }

    #[test]
    fn unicode_candidate_respects_token_budget() -> TestResult {
        // End-to-end: candidates whose content is mostly multi-codepoint
        // emoji, CJK, RTL, and combining marks must still pack under a
        // tight budget without overflow. We size each candidate so the
        // pair just barely fits and assert the assembled draft does not
        // exceed the budget under any of the Unicode flavours.
        let budget = TokenBudget::new(20).map_err(|error| format!("budget: {error:?}"))?;

        let emoji = candidate_with_content(1, 0.9, 0.8, 8, "🦀🔥💻 build the release")?;
        let cjk = candidate_with_content(2, 0.8, 0.8, 8, "中文字符 必须 也 计入 预算")?;
        let zwj =
            candidate_with_content(3, 0.7, 0.7, 6, "family: 👨\u{200D}👩\u{200D}👧\u{200D}👦")?;
        let rtl = candidate_with_content(4, 0.6, 0.6, 6, "shalom שלום and back to ascii")?;
        let combining =
            candidate_with_content(5, 0.5, 0.5, 6, "cafe\u{0301} resume\u{0301} naïve")?;

        let draft = assemble_draft(
            "ship a Unicode-safe pack",
            budget,
            vec![emoji, cjk, zwj, rtl, combining],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure(
            draft.used_tokens <= 20,
            format!(
                "Unicode candidates must respect budget=20, used={}",
                draft.used_tokens
            ),
        )?;
        ensure(
            !draft.items.is_empty(),
            "at least one Unicode candidate should fit",
        )?;
        // All non-selected candidates must show up as omissions, none silently dropped
        ensure_equal(
            &(draft.items.len() + draft.omitted.len()),
            &5,
            "every input candidate is accounted for",
        )
    }

    #[test]
    fn section_quota_unlimited_has_no_constraints() -> TestResult {
        let unlimited = SectionQuota::unlimited();
        ensure(
            unlimited.is_unlimited(),
            "unlimited should report as unlimited",
        )?;
        ensure(
            !unlimited.exceeds_max(1_000_000),
            "unlimited should not exceed max",
        )?;
        ensure_equal(
            &unlimited.remaining(1000),
            &u32::MAX,
            "unlimited remaining should be u32::MAX",
        )
    }

    #[test]
    fn section_quota_capped_enforces_maximum() -> TestResult {
        let capped = SectionQuota::capped(100);
        ensure(!capped.is_unlimited(), "capped should not be unlimited")?;
        ensure(!capped.exceeds_max(100), "100 should not exceed max of 100")?;
        ensure(capped.exceeds_max(101), "101 should exceed max of 100")?;
        ensure_equal(
            &capped.remaining(50),
            &50,
            "remaining after using 50 of 100",
        )?;
        ensure_equal(&capped.remaining(100), &0, "remaining after using all")?;
        ensure_equal(&capped.remaining(150), &0, "remaining when over quota")
    }

    #[test]
    fn section_quota_new_accepts_min_and_max() -> TestResult {
        let quota = SectionQuota::new(10, 100);
        ensure_equal(&quota.min_tokens, &10, "min tokens")?;
        ensure_equal(&quota.max_tokens, &100, "max tokens")
    }

    /// bd-2s2mv: a 0-basis-point section must reject candidates instead
    /// of silently becoming unlimited via the `capped(0)`/`unlimited()`
    /// max_tokens-sentinel collision. Build a section mix that disables
    /// every section but ProceduralRules and assert that only the
    /// procedural section reports room.
    #[test]
    fn section_quotas_from_zero_basis_points_disables_section() -> TestResult {
        let quota = super::SectionQuota::disabled();
        ensure(quota.is_disabled(), "disabled() should report as disabled")?;
        ensure(
            !quota.is_unlimited(),
            "disabled quota must not look unlimited (bd-2s2mv)",
        )?;
        ensure(quota.exceeds_max(1), "1 token should exceed disabled quota")?;
        ensure_equal(&quota.remaining(0), &0, "disabled remaining must be 0")?;
        ensure_equal(
            &quota.remaining(123),
            &0,
            "disabled remaining must stay 0 regardless of used",
        )?;

        let mix = super::ContextProfileSectionMix::new(10_000, 0, 0, 0, 0);
        let quotas = super::SectionQuotas::from_section_mix(mix, 1_000);

        ensure(
            quotas.has_room(PackSection::ProceduralRules, 0, 500),
            "procedural_rules (10_000 bp) must admit candidates",
        )?;
        for section in [
            PackSection::Decisions,
            PackSection::Failures,
            PackSection::Evidence,
            PackSection::Artifacts,
        ] {
            ensure(
                !quotas.has_room(section, 0, 1),
                format!("{section} has 0 basis points and must reject candidates (bd-2s2mv)"),
            )?;
            ensure(
                quotas.get(section).is_disabled(),
                format!("{section} quota must report disabled"),
            )?;
        }
        Ok(())
    }

    #[test]
    fn section_quotas_unlimited_allows_everything() -> TestResult {
        let quotas = SectionQuotas::unlimited();
        for section in PackSection::all() {
            ensure(
                quotas.get(section).is_unlimited(),
                format!("{section} should be unlimited"),
            )?;
            ensure(
                quotas.has_room(section, 10000, 10000),
                format!("{section} should have room"),
            )?;
        }
        Ok(())
    }

    #[test]
    fn section_quotas_balanced_allocates_percentages() -> TestResult {
        let quotas = SectionQuotas::balanced(1000);

        let procedural = quotas.get(PackSection::ProceduralRules);
        ensure(
            procedural.max_tokens >= 290 && procedural.max_tokens <= 310,
            format!(
                "procedural_rules should be ~30% (got {})",
                procedural.max_tokens
            ),
        )?;

        let decisions = quotas.get(PackSection::Decisions);
        ensure(
            decisions.max_tokens >= 190 && decisions.max_tokens <= 210,
            format!("decisions should be ~20% (got {})", decisions.max_tokens),
        )?;

        let artifacts = quotas.get(PackSection::Artifacts);
        ensure(
            artifacts.max_tokens >= 90 && artifacts.max_tokens <= 110,
            format!("artifacts should be ~10% (got {})", artifacts.max_tokens),
        )
    }

    #[test]
    fn section_quotas_compact_prioritizes_procedural_rules() -> TestResult {
        let quotas = SectionQuotas::compact(1000);

        let procedural = quotas.get(PackSection::ProceduralRules);
        ensure(
            procedural.max_tokens >= 490 && procedural.max_tokens <= 510,
            format!(
                "procedural_rules should be ~50% in compact (got {})",
                procedural.max_tokens
            ),
        )
    }

    #[test]
    fn section_quotas_thorough_is_more_even() -> TestResult {
        let quotas = SectionQuotas::thorough(1000);

        let procedural = quotas.get(PackSection::ProceduralRules);
        let evidence = quotas.get(PackSection::Evidence);

        ensure(
            procedural.max_tokens >= 190 && procedural.max_tokens <= 210,
            format!(
                "procedural_rules should be ~20% in thorough (got {})",
                procedural.max_tokens
            ),
        )?;
        ensure(
            evidence.max_tokens >= 240 && evidence.max_tokens <= 260,
            format!(
                "evidence should be ~25% in thorough (got {})",
                evidence.max_tokens
            ),
        )
    }

    #[test]
    fn section_quotas_for_profile_dispatches_correctly() -> TestResult {
        let compact = SectionQuotas::for_profile(ContextPackProfile::Compact, 1000);
        let balanced = SectionQuotas::for_profile(ContextPackProfile::Balanced, 1000);
        let thorough = SectionQuotas::for_profile(ContextPackProfile::Thorough, 1000);

        ensure(
            compact.get(PackSection::ProceduralRules).max_tokens
                > balanced.get(PackSection::ProceduralRules).max_tokens,
            "compact should give more to procedural_rules than balanced",
        )?;
        ensure(
            thorough.get(PackSection::Evidence).max_tokens
                > balanced.get(PackSection::Evidence).max_tokens,
            "thorough should give more to evidence than balanced",
        )
    }

    #[test]
    fn section_quotas_follow_context_profile_model() -> TestResult {
        let profile = ContextProfile::builtin(ContextPackProfile::Compact);
        let quotas = SectionQuotas::for_profile(profile.name, 1000);

        ensure_equal(
            &quotas.get(PackSection::ProceduralRules).max_tokens,
            &500,
            "compact procedural quota",
        )?;
        ensure_equal(
            &quotas.get(PackSection::Evidence).max_tokens,
            &100,
            "compact evidence quota",
        )?;
        ensure_equal(
            &profile.section_mix.total_bps(),
            &10_000,
            "profile section mix total",
        )
    }

    #[test]
    fn profile_specific_quotas_match_builtin_context_profiles() -> TestResult {
        let expected = [
            (ContextPackProfile::Compact, [50, 15, 20, 10, 5]),
            (ContextPackProfile::Balanced, [30, 20, 20, 20, 10]),
            (ContextPackProfile::Grounding, [30, 20, 20, 20, 10]),
            (ContextPackProfile::Orientation, [30, 20, 20, 20, 10]),
            (ContextPackProfile::Thorough, [20, 20, 20, 25, 15]),
            (ContextPackProfile::Submodular, [20, 20, 20, 25, 15]),
        ];

        for (profile, [procedural, decisions, failures, evidence, artifacts]) in expected {
            let quotas = SectionQuotas::for_profile(profile, 100);
            ensure_equal(
                &quotas.get(PackSection::ProceduralRules).max_tokens,
                &procedural,
                &format!("{profile} procedural quota"),
            )?;
            ensure_equal(
                &quotas.get(PackSection::Decisions).max_tokens,
                &decisions,
                &format!("{profile} decisions quota"),
            )?;
            ensure_equal(
                &quotas.get(PackSection::Failures).max_tokens,
                &failures,
                &format!("{profile} failures quota"),
            )?;
            ensure_equal(
                &quotas.get(PackSection::Evidence).max_tokens,
                &evidence,
                &format!("{profile} evidence quota"),
            )?;
            ensure_equal(
                &quotas.get(PackSection::Artifacts).max_tokens,
                &artifacts,
                &format!("{profile} artifacts quota"),
            )?;
        }
        Ok(())
    }

    #[test]
    fn profile_specific_compact_allows_larger_procedural_rules() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let procedural_rule = candidate_in_section(
            101,
            PackSection::ProceduralRules,
            1.0,
            0.5,
            40,
            "Run release verification commands through rch.",
        )?;

        let compact = assemble_classic_draft_with_profile(
            ContextPackProfile::Compact,
            "prepare release",
            budget,
            vec![procedural_rule.clone()],
        )
        .map_err(|error| format!("compact draft rejected: {error:?}"))?;
        let balanced = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            vec![procedural_rule],
        )
        .map_err(|error| format!("balanced draft rejected: {error:?}"))?;

        ensure_equal(
            &compact.items.first().map(|item| item.memory_id),
            &Some(memory_id(101)),
            "compact selects the 40-token procedural rule",
        )?;
        ensure_equal(
            &balanced.items.len(),
            &0,
            "balanced omits the procedural rule above its section quota",
        )?;
        ensure_equal(
            &balanced.omitted.first().map(|omission| omission.reason),
            &Some(PackOmissionReason::TokenBudgetExceeded),
            "balanced omission reason",
        )
    }

    #[test]
    fn profile_specific_thorough_allows_larger_evidence_items() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let evidence = candidate_in_section(
            202,
            PackSection::Evidence,
            1.0,
            0.7,
            25,
            "Release artifacts were signed and checksums matched.",
        )?;

        let thorough = assemble_classic_draft_with_profile(
            ContextPackProfile::Thorough,
            "prepare release",
            budget,
            vec![evidence.clone()],
        )
        .map_err(|error| format!("thorough draft rejected: {error:?}"))?;
        let balanced = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            vec![evidence],
        )
        .map_err(|error| format!("balanced draft rejected: {error:?}"))?;

        ensure_equal(
            &thorough.items.first().map(|item| item.memory_id),
            &Some(memory_id(202)),
            "thorough selects the 25-token evidence item",
        )?;
        ensure_equal(
            &balanced.items.len(),
            &0,
            "balanced omits evidence above its section quota",
        )?;
        ensure_equal(
            &balanced.omitted.first().map(|omission| omission.reason),
            &Some(PackOmissionReason::TokenBudgetExceeded),
            "balanced evidence omission reason",
        )
    }

    #[test]
    fn section_quotas_has_room_checks_capacity() -> TestResult {
        let quotas = SectionQuotas::balanced(100);
        let section = PackSection::ProceduralRules;
        let max = quotas.get(section).max_tokens;

        ensure(
            quotas.has_room(section, 0, max),
            "should have room for max tokens when unused",
        )?;
        ensure(
            !quotas.has_room(section, 0, max + 1),
            "should not have room for more than max",
        )?;
        ensure(
            quotas.has_room(section, max - 10, 10),
            "should have room for exactly remaining",
        )?;
        ensure(
            !quotas.has_room(section, max - 10, 11),
            "should not have room when would exceed",
        )
    }

    #[test]
    fn section_quotas_remaining_tracks_usage() -> TestResult {
        let quotas = SectionQuotas::balanced(100);
        let section = PackSection::ProceduralRules;
        let max = quotas.get(section).max_tokens;

        ensure_equal(
            &quotas.remaining(section, 0),
            &max,
            "remaining when unused equals max",
        )?;
        ensure_equal(
            &quotas.remaining(section, max),
            &0,
            "remaining when fully used is 0",
        )?;
        ensure_equal(
            &quotas.remaining(section, max + 10),
            &0,
            "remaining when over quota is 0",
        )
    }

    #[test]
    fn profile_and_section_wire_names_are_stable() -> TestResult {
        ensure_equal(
            &ContextPackProfile::Compact.as_str(),
            &"compact",
            "compact profile",
        )?;
        ensure_equal(
            &ContextPackProfile::Balanced.to_string().as_str(),
            &"balanced",
            "balanced profile display",
        )?;
        ensure_equal(
            &ContextPackProfile::Grounding.as_str(),
            &"grounding",
            "grounding profile",
        )?;
        ensure_equal(
            &ContextPackProfile::Orientation.as_str(),
            &"orientation",
            "orientation profile",
        )?;
        ensure_equal(
            &ContextPackProfile::Submodular.as_str(),
            &"submodular",
            "submodular profile",
        )?;
        ensure_equal(
            &PackSection::all().map(PackSection::as_str),
            &[
                "procedural_rules",
                "decisions",
                "failures",
                "evidence",
                "artifacts",
            ],
            "section order",
        )
    }

    #[test]
    fn token_budget_rejects_zero_and_keeps_default_stable() -> TestResult {
        let zero = TokenBudget::new(0);
        ensure(
            matches!(zero, Err(PackValidationError::ZeroTokenBudget)),
            "zero token budget must be rejected",
        )?;
        ensure_equal(
            &TokenBudget::default_context().max_tokens(),
            &4_000,
            "default context budget",
        )
    }

    #[test]
    fn context_request_defaults_are_stable() -> TestResult {
        let request = ContextRequest::from_query(" prepare release ")
            .map_err(|error| format!("request rejected: {error:?}"))?;

        ensure_equal(&request.query.as_str(), &"prepare release", "trimmed query")?;
        ensure_equal(
            &request.profile,
            &ContextPackProfile::Balanced,
            "default profile",
        )?;
        ensure_equal(&request.budget.max_tokens(), &4_000, "default max tokens")?;
        ensure_equal(&request.candidate_pool, &64, "default candidate pool")?;
        ensure_equal(
            &request.sections,
            &PackSection::all().to_vec(),
            "default sections",
        )
    }

    #[test]
    fn context_request_accepts_explicit_profile_budget_pool_and_sections() -> TestResult {
        let request = ContextRequest::new(ContextRequestInput {
            query: "fix release workflow".to_string(),
            profile: Some(ContextPackProfile::Thorough),
            max_tokens: Some(8_000),
            candidate_pool: Some(12),
            max_results: Some(3),
            sections: vec![PackSection::ProceduralRules, PackSection::Failures],
        })
        .map_err(|error| format!("request rejected: {error:?}"))?;

        ensure_equal(
            &request.profile,
            &ContextPackProfile::Thorough,
            "explicit profile",
        )?;
        ensure_equal(&request.budget.max_tokens(), &8_000, "explicit max tokens")?;
        ensure_equal(&request.candidate_pool, &12, "explicit candidate pool")?;
        ensure_equal(&request.max_results, &Some(3), "explicit max results")?;
        ensure_equal(
            &request.sections,
            &vec![PackSection::ProceduralRules, PackSection::Failures],
            "explicit sections",
        )
    }

    #[test]
    fn context_request_rejects_empty_query_and_zero_limits() -> TestResult {
        let empty_query = ContextRequest::from_query(" ");
        ensure(
            matches!(empty_query, Err(PackValidationError::EmptyQuery)),
            "empty context query must be rejected",
        )?;

        let zero_budget = ContextRequest::new(ContextRequestInput {
            query: "task".to_string(),
            profile: None,
            max_tokens: Some(0),
            candidate_pool: None,
            max_results: None,
            sections: Vec::new(),
        });
        ensure(
            matches!(zero_budget, Err(PackValidationError::ZeroTokenBudget)),
            "zero max tokens must be rejected",
        )?;

        let zero_pool = ContextRequest::new(ContextRequestInput {
            query: "task".to_string(),
            profile: None,
            max_tokens: None,
            candidate_pool: Some(0),
            max_results: None,
            sections: Vec::new(),
        });
        ensure(
            matches!(zero_pool, Err(PackValidationError::ZeroCandidatePool)),
            "zero candidate pool must be rejected",
        )?;

        let zero_results = ContextRequest::new(ContextRequestInput {
            query: "task".to_string(),
            profile: None,
            max_tokens: None,
            candidate_pool: None,
            max_results: Some(0),
            sections: Vec::new(),
        });
        ensure(
            matches!(zero_results, Err(PackValidationError::ZeroMaxResults)),
            "zero max results must be rejected",
        )
    }

    #[test]
    fn candidate_requires_content_provenance_tokens_and_why() -> TestResult {
        let id = memory_id(7);
        let base_provenance = vec![provenance("file://src/lib.rs#L1")?];

        let empty_content = PackCandidate::new(candidate_input(
            id,
            PackSection::Evidence,
            " ",
            5,
            base_provenance.clone(),
            "matches query",
        )?);
        ensure(
            matches!(
                empty_content,
                Err(PackValidationError::EmptyCandidateContent { .. })
            ),
            "empty content must be rejected",
        )?;

        let zero_tokens = PackCandidate::new(candidate_input(
            id,
            PackSection::Evidence,
            "memory",
            0,
            base_provenance.clone(),
            "matches query",
        )?);
        ensure(
            matches!(
                zero_tokens,
                Err(PackValidationError::ZeroCandidateTokens { .. })
            ),
            "zero-token candidate must be rejected",
        )?;

        let no_provenance = PackCandidate::new(candidate_input(
            id,
            PackSection::Evidence,
            "memory",
            5,
            Vec::new(),
            "matches query",
        )?);
        ensure(
            matches!(
                no_provenance,
                Err(PackValidationError::MissingProvenance { .. })
            ),
            "missing provenance must be rejected",
        )?;

        let no_why = PackCandidate::new(candidate_input(
            id,
            PackSection::Evidence,
            "memory",
            5,
            base_provenance,
            " ",
        )?);
        ensure(
            matches!(no_why, Err(PackValidationError::MissingWhy { .. })),
            "missing why must be rejected",
        )
    }

    #[test]
    fn pack_score_breakdown_sanitizes_non_finite_scores() -> TestResult {
        let breakdown = PackScoreBreakdown::ppr(f32::NAN, f32::INFINITY, -0.5);

        ensure_equal(&breakdown.text_score, &0.0, "nan text score")?;
        ensure_equal(&breakdown.ppr_score, &0.0, "infinite ppr score")?;
        ensure_equal(&breakdown.combined_score, &0.0, "negative combined score")
    }

    #[test]
    fn pack_provenance_rendering_labels_sources() -> TestResult {
        let source = provenance("file://src/lib.rs#L42")?;
        let rendered = source.rendered();
        let locator = rendered.locator.as_deref();

        ensure_equal(
            &rendered.uri.as_str(),
            &"file://src/lib.rs#L42",
            "rendered URI",
        )?;
        ensure_equal(&rendered.scheme.as_str(), &"file", "rendered scheme")?;
        ensure_equal(
            &rendered.label.as_str(),
            &"src/lib.rs:L42",
            "rendered label",
        )?;
        ensure_equal(&locator, &Some("L42"), "rendered locator")?;
        ensure_equal(&rendered.note.as_str(), &"source evidence", "rendered note")
    }

    #[test]
    fn pack_provenance_rendering_redacts_sensitive_sources() -> TestResult {
        let uri = ProvenanceUri::from_str(
            "file:///Users/alice/private/logs/build.log?api_key=redaction-fixture#L42",
        )
        .map_err(|error| format!("test provenance URI rejected: {error:?}"))?;
        let source = PackProvenance::new(uri, "source api_key=redaction-fixture")
            .map_err(|error| format!("test provenance note rejected: {error:?}"))?;

        let rendered = source.rendered();
        let combined = format!(
            "{}\n{}\n{:?}\n{}",
            rendered.uri, rendered.label, rendered.locator, rendered.note
        );

        ensure(
            combined.contains("[REDACTED_PATH]"),
            "rendered provenance should retain a path placeholder",
        )?;
        ensure(
            combined.contains("[REDACTED:api_key]"),
            "rendered provenance should retain a secret placeholder",
        )?;
        ensure(
            !combined.contains("/Users/alice/private/logs/build.log"),
            "rendered provenance must not leak absolute paths",
        )?;
        ensure(
            !combined.contains("redaction-fixture"),
            "rendered provenance must not leak secret-like values",
        )
    }

    #[test]
    fn pack_item_provenance_json_preserves_full_sources() -> TestResult {
        let json = pack_item_provenance_json(&[
            provenance("file://src/lib.rs#L42")?,
            provenance("cass-session://session-a#L20-22")?,
        ]);
        let value: serde_json::Value =
            serde_json::from_str(&json).map_err(|error| error.to_string())?;

        ensure_equal(
            &value["schema"],
            &serde_json::json!(super::PACK_ITEM_PROVENANCE_SCHEMA_V1),
            "provenance schema",
        )?;
        ensure_equal(
            &value["entries"][0]["uri"],
            &serde_json::json!("file://src/lib.rs#L42"),
            "first provenance uri",
        )?;
        ensure_equal(
            &value["entries"][0]["note"],
            &serde_json::json!("source evidence"),
            "first provenance note",
        )?;
        ensure_equal(
            &value["entries"][1]["uri"],
            &serde_json::json!("cass-session://session-a#L20-22"),
            "second provenance uri",
        )
    }

    #[test]
    fn pack_item_provenance_json_redacts_sensitive_sources() -> TestResult {
        let uri = ProvenanceUri::from_str(
            "file:///Users/alice/private/logs/build.log?api_key=redaction-fixture#L42",
        )
        .map_err(|error| format!("test provenance URI rejected: {error:?}"))?;
        let source = PackProvenance::new(uri, "source api_key=redaction-fixture")
            .map_err(|error| format!("test provenance note rejected: {error:?}"))?;
        let json = pack_item_provenance_json(&[source]);
        let value: serde_json::Value =
            serde_json::from_str(&json).map_err(|error| error.to_string())?;
        let rendered = value.to_string();

        ensure_equal(
            &value["entries"][0]["uri"],
            &serde_json::json!("file://[REDACTED_PATH]?api_key=[REDACTED:api_key]#L42"),
            "redacted provenance uri",
        )?;
        ensure_equal(
            &value["entries"][0]["note"],
            &serde_json::json!("source api_key=[REDACTED:api_key]"),
            "redacted provenance note",
        )?;
        ensure(
            !rendered.contains("/Users/alice/private/logs/build.log"),
            "persisted provenance JSON must not leak absolute paths",
        )?;
        ensure(
            !rendered.contains("redaction-fixture"),
            "persisted provenance JSON must not leak secret-like values",
        )
    }

    #[test]
    fn pack_provenance_footer_is_deterministic() -> TestResult {
        let id = memory_id(8);
        let candidate = PackCandidate::new(candidate_input(
            id,
            PackSection::Evidence,
            "Use the AGENTS.md release rule before shipping.",
            12,
            vec![
                provenance("file://AGENTS.md#L10")?,
                provenance("cass-session://session-a#L20-22")?,
            ],
            "selected because release rules match the query",
        )?)
        .map_err(|error| format!("candidate rejected: {error:?}"))?;
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let draft = assemble_draft("prepare release", budget, vec![candidate])
            .map_err(|error| format!("draft rejected: {error:?}"))?;

        let footer = draft.provenance_footer();

        ensure_equal(&footer.memory_count, &1, "footer memory count")?;
        ensure_equal(&footer.source_count, &2, "footer source count")?;
        ensure_equal(
            &footer.schemes,
            &vec!["cass-session".to_owned(), "file".to_owned()],
            "footer schemes",
        )?;
        ensure_equal(
            &footer.entries.first().map(|entry| entry.rank),
            &Some(1),
            "first footer rank",
        )?;
        ensure_equal(
            &footer.entries.first().map(|entry| entry.source_index),
            &Some(1),
            "first source index",
        )?;
        ensure_equal(
            &footer
                .entries
                .get(1)
                .map(|entry| entry.source.label.as_str()),
            &Some("cass-session session-a#L20-22"),
            "second source label",
        )
    }

    #[test]
    fn pack_quality_metrics_summarize_selected_and_omitted_items() -> TestResult {
        let budget = TokenBudget::new(48).map_err(|error| format!("budget rejected: {error:?}"))?;
        // redundant must have SAME CONTENT to be truly redundant (not just same diversity_key)
        let shared_content = "Run cargo fmt --check before release.";
        let first = candidate_in_section(
            1,
            PackSection::ProceduralRules,
            1.0,
            0.5,
            10,
            shared_content,
        )?
        .with_diversity_key("release-formatting");
        let redundant =
            candidate_in_section(2, PackSection::ProceduralRules, 0.9, 0.6, 4, shared_content)?
                .with_diversity_key("release-formatting");
        let evidence = candidate_in_section(
            3,
            PackSection::Evidence,
            0.8,
            0.7,
            9,
            "The release checklist includes formatting evidence.",
        )?;
        let over_budget = candidate_in_section(
            4,
            PackSection::Failures,
            0.7,
            0.4,
            27,
            "A prior release failed after skipping formatter checks.",
        )?;

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            vec![redundant, over_budget, evidence, first],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let metrics = draft.quality_metrics();

        ensure_equal(&metrics.item_count, &3, "metric item count")?;
        ensure_equal(&metrics.omitted_count, &1, "metric omitted count")?;
        ensure_equal(&metrics.used_tokens, &23, "metric used tokens")?;
        ensure_equal(&metrics.max_tokens, &48, "metric max tokens")?;
        ensure_close(
            metrics.budget_utilization,
            23.0_f32 / 48.0_f32,
            "budget utilization",
        )?;
        ensure_close(metrics.average_relevance, 0.9, "average relevance")?;
        ensure_close(metrics.average_utility, 0.6, "average utility")?;
        ensure_equal(
            &metrics.provenance_source_count,
            &3,
            "provenance source count",
        )?;
        ensure_close(
            metrics.provenance_sources_per_item,
            1.0,
            "provenance sources per item",
        )?;
        ensure(
            metrics.provenance_complete,
            "selected items have provenance",
        )?;
        ensure_equal(
            &metrics.coverage_fill_count,
            &1,
            "coverage fill metric count",
        )?;

        let procedural = metrics
            .sections
            .iter()
            .find(|metric| metric.section == PackSection::ProceduralRules)
            .ok_or_else(|| "missing procedural section metric".to_string())?;
        ensure_equal(&procedural.item_count, &2, "procedural item count")?;
        ensure_equal(&procedural.used_tokens, &14, "procedural tokens")?;

        let evidence = metrics
            .sections
            .iter()
            .find(|metric| metric.section == PackSection::Evidence)
            .ok_or_else(|| "missing evidence section metric".to_string())?;
        ensure_equal(&evidence.item_count, &1, "evidence item count")?;
        ensure_equal(&evidence.used_tokens, &9, "evidence tokens")?;

        ensure_equal(
            &metrics.omissions.token_budget_exceeded,
            &1,
            "budget omission count",
        )?;
        ensure_equal(
            &metrics.omissions.redundant_candidates,
            &0,
            "redundant omission count",
        )?;
        ensure_equal(
            &metrics.omissions.below_relevance_floor,
            &0,
            "below-floor omission count",
        )
    }

    #[test]
    fn pack_quality_metrics_are_stable_for_empty_draft() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let draft = assemble_draft("empty", budget, Vec::<PackCandidate>::new())
            .map_err(|error| format!("draft rejected: {error:?}"))?;
        let metrics = draft.quality_metrics();

        ensure_equal(&metrics.item_count, &0, "empty item count")?;
        ensure_equal(&metrics.omitted_count, &0, "empty omitted count")?;
        ensure_equal(&metrics.used_tokens, &0, "empty used tokens")?;
        ensure_equal(&metrics.max_tokens, &100, "empty max tokens")?;
        ensure_close(metrics.budget_utilization, 0.0, "empty utilization")?;
        ensure_close(metrics.average_relevance, 0.0, "empty relevance")?;
        ensure_close(metrics.average_utility, 0.0, "empty utility")?;
        ensure_equal(
            &metrics.provenance_source_count,
            &0,
            "empty provenance source count",
        )?;
        ensure_close(
            metrics.provenance_sources_per_item,
            0.0,
            "empty provenance density",
        )?;
        ensure_equal(
            &metrics.coverage_fill_count,
            &0,
            "empty coverage fill count",
        )?;
        ensure(
            metrics.provenance_complete,
            "empty packs have no missing provenance entries",
        )?;
        ensure_equal(
            &metrics
                .sections
                .iter()
                .map(|metric| metric.section)
                .collect::<Vec<_>>(),
            &PackSection::all().to_vec(),
            "empty section order",
        )?;
        for metric in &metrics.sections {
            ensure_equal(&metric.item_count, &0, "empty section item count")?;
            ensure_equal(&metric.used_tokens, &0, "empty section tokens")?;
        }
        ensure_equal(
            &metrics.omissions.token_budget_exceeded,
            &0,
            "empty budget omissions",
        )?;
        ensure_equal(
            &metrics.omissions.redundant_candidates,
            &0,
            "empty redundant omissions",
        )?;
        ensure_equal(
            &metrics.omissions.below_relevance_floor,
            &0,
            "empty below-floor omissions",
        )
    }

    #[test]
    fn assemble_draft_orders_candidates_deterministically() -> TestResult {
        let budget = match TokenBudget::new(100) {
            Ok(budget) => budget,
            Err(error) => return Err(format!("budget rejected: {error:?}")),
        };
        let lower_id = candidate(1, 0.9, 0.7, 10)?;
        let higher_utility = candidate(2, 0.9, 0.9, 10)?;
        let lower_relevance = candidate(3, 0.8, 1.0, 10)?;

        let draft = assemble_draft(
            "release workflow",
            budget,
            vec![lower_relevance, lower_id, higher_utility],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let ids: Vec<MemoryId> = draft.items.iter().map(|item| item.memory_id).collect();
        ensure_equal(
            &ids,
            &vec![memory_id(2), memory_id(1), memory_id(3)],
            "deterministic rank order",
        )?;
        ensure_equal(
            &draft.items.first().map(|item| item.rank),
            &Some(1),
            "first rank",
        )?;
        ensure_equal(
            &draft.items.get(1).map(|item| item.rank),
            &Some(2),
            "second rank",
        )
    }

    #[test]
    fn consensus_member_memory_ids_use_typed_memory_id_order() -> TestResult {
        let shared = "Run cargo fmt before release.";
        let draft = draft_from_candidates(vec![
            candidate_with_content(3, 0.8, 0.5, 10, shared)?.with_diversity_key("release-format"),
            candidate_with_content(1, 0.8, 0.5, 10, shared)?.with_diversity_key("release-format"),
            candidate_with_content(2, 0.8, 0.5, 10, shared)?.with_diversity_key("release-format"),
        ])?;

        let report = super::analyze_pack_consensus_conflicts(&draft);

        ensure_equal(
            &report.conflicts.len(),
            &0,
            "no conflicts for matching content",
        )?;
        ensure_equal(&report.consensus.len(), &1, "single consensus group")?;
        ensure_equal(
            &report.consensus[0].member_memory_ids,
            &vec![memory_id(1), memory_id(2), memory_id(3)],
            "consensus member memory id order",
        )
    }

    #[test]
    fn conflict_memory_ids_use_typed_memory_id_order() -> TestResult {
        let draft = draft_from_candidates(vec![
            candidate_with_content(3, 0.8, 0.5, 10, "Always run cargo fmt before release.")?
                .with_diversity_key("release-format"),
            candidate_with_content(1, 0.8, 0.5, 10, "Never run cargo fmt before release.")?
                .with_diversity_key("release-format"),
        ])?;

        let report = super::analyze_pack_consensus_conflicts(&draft);

        ensure_equal(
            &report.consensus.len(),
            &0,
            "no consensus for direct conflict",
        )?;
        ensure_equal(&report.conflicts.len(), &1, "single direct conflict")?;
        ensure_equal(
            &report.conflicts[0].conflicting_memory_ids,
            &vec![memory_id(1), memory_id(3)],
            "conflict memory id order",
        )
    }

    #[test]
    fn assemble_draft_redacts_secret_like_content_before_emit() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let raw_value = format!("{}{}", concat!("sk", "-ant", "-api03", "-"), "A".repeat(52));
        let original_estimate = 80;
        let content = format!("Preserve the note but mask {raw_value}.");

        let draft = assemble_draft(
            "protect context pack secrets",
            budget,
            vec![candidate_with_content(
                42,
                1.0,
                0.8,
                original_estimate,
                content,
            )?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let item = draft
            .items
            .first()
            .ok_or_else(|| "expected selected item".to_string())?;

        ensure(
            !item.content.contains(&raw_value),
            "selected pack item should not retain raw secret-like value",
        )?;
        ensure_contains(
            &item.content,
            &crate::policy::redaction_placeholder("anthropic_api_key"),
            "selected pack item includes deterministic redaction placeholder",
        )?;
        let expected_rendered_tokens = estimate_tokens_default(&item.content);
        ensure_equal(
            &item.estimated_tokens,
            &expected_rendered_tokens,
            "selected pack item token estimate matches rendered content",
        )?;
        ensure(
            item.estimated_tokens < original_estimate,
            "redacted pack item should not keep pre-redaction token estimate",
        )?;
        ensure_equal(
            &draft.used_tokens,
            &expected_rendered_tokens,
            "draft used tokens match rendered selected content",
        )?;
        ensure_equal(
            &draft.selection_audit.budget_used,
            &expected_rendered_tokens,
            "selection audit budget uses rendered selected content",
        )?;
        let selected_token_cost = draft
            .selection_audit
            .selected_items
            .first()
            .map(|item| item.token_cost)
            .ok_or_else(|| "expected selected certificate item".to_string())?;
        ensure_equal(
            &selected_token_cost,
            &expected_rendered_tokens,
            "selection audit selected token cost uses rendered content",
        )?;
        let step_token_cost = draft
            .selection_audit
            .steps
            .first()
            .map(|step| step.token_cost)
            .ok_or_else(|| "expected selection audit step".to_string())?;
        ensure_equal(
            &step_token_cost,
            &expected_rendered_tokens,
            "selection audit step token cost uses rendered content",
        )?;
        ensure(
            item.redactions
                .contains(&PackItemRedaction::new("anthropic_api_key")),
            "selected pack item records redaction reason",
        )
    }

    #[test]
    fn assemble_draft_can_disable_output_redaction() -> TestResult {
        let budget =
            TokenBudget::new(400).map_err(|error| format!("budget rejected: {error:?}"))?;
        let raw_value = format!("{}{}", concat!("sk", "-ant", "-api03", "-"), "D".repeat(52));
        let content = format!("Workspace policy allows raw output for {raw_value}.");

        let draft = super::assemble_draft_with_profile_and_options(
            ContextPackProfile::Balanced,
            "inspect output redaction policy",
            budget,
            vec![candidate_with_content(45, 1.0, 0.8, 80, content)?],
            PackAssemblyOptions {
                output_redaction_enabled: false,
                ..PackAssemblyOptions::default()
            },
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let item = draft
            .items
            .first()
            .ok_or_else(|| "expected selected item".to_string())?;

        ensure(
            item.content.contains(&raw_value),
            "disabled output redaction should retain raw secret-like value",
        )?;
        ensure_equal(
            &item.redactions,
            &Vec::<PackItemRedaction>::new(),
            "disabled output redaction should not record per-item redactions",
        )
    }

    #[test]
    fn seeded_mmr_pack_assembly_matches_default_selection() -> TestResult {
        let budget =
            TokenBudget::new(400).map_err(|error| format!("budget rejected: {error:?}"))?;
        let candidates = vec![
            candidate_with_content(45, 0.9, 0.8, 80, "Prefer cargo fmt before release.")?,
            candidate_with_content(46, 0.7, 0.6, 80, "Run clippy with warnings denied.")?,
        ];
        let seeded = assemble_draft_with_profile_and_options_seeded(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates.clone(),
            PackAssemblyOptions::default(),
            &Deterministic::from_seed(123),
        )
        .map_err(|error| format!("seeded draft rejected: {error:?}"))?;
        let default = super::assemble_draft_with_profile_and_options(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates,
            PackAssemblyOptions::default(),
        )
        .map_err(|error| format!("default draft rejected: {error:?}"))?;

        let seeded_ids = seeded
            .items
            .iter()
            .map(|item| item.memory_id)
            .collect::<Vec<_>>();
        let default_ids = default
            .items
            .iter()
            .map(|item| item.memory_id)
            .collect::<Vec<_>>();
        ensure_equal(
            &seeded_ids,
            &default_ids,
            "threading a deterministic token does not alter MMR selection",
        )
    }

    #[test]
    fn submodular_draft_used_tokens_match_post_redaction_content() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let raw_value = format!("{}{}", concat!("sk", "-ant", "-api03", "-"), "B".repeat(52));
        let original_estimate = 80;
        let content = format!("Facility selection must mask {raw_value} before budgeting.");

        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "protect context pack secrets",
            budget,
            vec![candidate_with_content(
                43,
                1.0,
                0.8,
                original_estimate,
                content,
            )?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let item = draft
            .items
            .first()
            .ok_or_else(|| "expected selected item".to_string())?;

        ensure(
            !item.content.contains(&raw_value),
            "submodular pack item should not retain raw secret-like value",
        )?;
        let expected_rendered_tokens = estimate_tokens_default(&item.content);
        ensure_equal(
            &item.estimated_tokens,
            &expected_rendered_tokens,
            "submodular item token estimate matches post-redaction content",
        )?;
        ensure(
            item.estimated_tokens < original_estimate,
            "submodular item should not keep pre-redaction token estimate",
        )?;
        ensure_equal(
            &draft.used_tokens,
            &expected_rendered_tokens,
            "submodular draft used tokens match rendered content",
        )?;
        ensure_equal(
            &draft.selection_audit.budget_used,
            &expected_rendered_tokens,
            "submodular certificate budget uses rendered content",
        )?;
        ensure_equal(
            &draft
                .selection_audit
                .selected_items
                .first()
                .map(|item| item.token_cost),
            &Some(expected_rendered_tokens),
            "submodular selected token cost uses rendered content",
        )?;
        ensure_equal(
            &draft
                .selection_audit
                .steps
                .first()
                .map(|step| step.token_cost),
            &Some(expected_rendered_tokens),
            "submodular step token cost uses rendered content",
        )?;
        ensure(
            item.redactions
                .contains(&PackItemRedaction::new("anthropic_api_key")),
            "submodular selected pack item records redaction reason",
        )
    }

    #[test]
    fn redacted_pack_candidate_never_has_zero_token_estimate() -> TestResult {
        let raw_value = format!("{}{}", concat!("sk", "-ant", "-api03", "-"), "C".repeat(52));
        let candidate = candidate_with_content(44, 1.0, 0.8, 80, raw_value)?;

        let (redacted, redactions) = super::redact_pack_candidate(candidate);

        ensure(
            !redactions.is_empty(),
            "fixture should exercise the redaction path",
        )?;
        ensure(
            redacted.estimated_tokens >= 1,
            "redacted pack candidate token estimate must stay positive",
        )?;
        ensure_equal(
            &redacted.estimated_tokens,
            &estimate_tokens_default(&redacted.content).max(1),
            "redacted pack candidate uses rendered token estimate with one-token floor",
        )
    }

    #[test]
    fn assemble_draft_omits_items_that_exceed_budget() -> TestResult {
        let budget = match TokenBudget::new(34) {
            Ok(budget) => budget,
            Err(error) => return Err(format!("budget rejected: {error:?}")),
        };

        let draft = assemble_draft(
            "format before release",
            budget,
            vec![candidate(1, 1.0, 0.5, 10)?, candidate(2, 0.9, 0.5, 10)?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(&draft.used_tokens, &10, "used token count")?;
        ensure_equal(&draft.items.len(), &1, "selected item count")?;
        ensure_equal(&draft.omitted.len(), &1, "omitted item count")?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.reason),
            &Some(PackOmissionReason::TokenBudgetExceeded),
            "omission reason",
        )?;
        ensure_equal(
            &draft
                .omitted
                .first()
                .map(|omission| omission.reason.as_str()),
            &Some("token_budget_exceeded"),
            "omission reason wire name",
        )
    }

    #[test]
    fn assemble_draft_applies_mmr_redundancy_control() -> TestResult {
        let budget = match TokenBudget::new(100) {
            Ok(budget) => budget,
            Err(error) => return Err(format!("budget rejected: {error:?}")),
        };
        // Duplicate must have SAME CONTENT to be redundant (not just same diversity_key)
        let shared_content = "Run cargo fmt --check before release.";
        let first = candidate_with_content(1, 1.0, 0.5, 10, shared_content)?
            .with_diversity_key("release-formatting");
        let duplicate = candidate_with_content(2, 0.99, 0.5, 10, shared_content)?
            .with_diversity_key("release-formatting");
        let diverse = candidate_with_content(3, 0.8, 0.5, 10, "Verify release checksums.")?
            .with_diversity_key("release-checks");

        let draft = assemble_draft("prepare release", budget, vec![duplicate, diverse, first])
            .map_err(|error| format!("draft rejected: {error:?}"))?;

        let ids: Vec<MemoryId> = draft.items.iter().map(|item| item.memory_id).collect();
        ensure_equal(
            &ids,
            &vec![memory_id(1), memory_id(3), memory_id(2)],
            "MMR should select strict candidates first, then fill with the redundant candidate",
        )?;
        ensure_equal(&draft.used_tokens, &30, "used tokens after coverage fill")?;
        ensure_equal(
            &draft.items.get(2).map(|item| item.selected_in),
            &Some(PackSelectionPhase::CoverageFill),
            "redundant candidate selected by coverage fill",
        )?;
        ensure_equal(
            &draft.omitted.len(),
            &0,
            "no candidate omitted when fill can use budget",
        )
    }

    #[test]
    fn anti_pattern_first_reserves_failure_slice_under_tight_budget() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let anti_pattern = candidate_in_section(
            90,
            PackSection::Failures,
            0.60,
            0.90,
            10,
            "Do not run local Cargo builds during code-first swarm batches.",
        )?
        .with_diversity_key("anti-pattern:local-cargo");
        let primary_rule = candidate_in_section(
            1,
            PackSection::ProceduralRules,
            1.00,
            0.80,
            15,
            "Use the central batch verifier for Rust proof.",
        )?
        .with_diversity_key("rule:central-verify");
        let squeezed_rule = candidate_in_section(
            2,
            PackSection::ProceduralRules,
            0.99,
            0.80,
            15,
            "Keep commits small and push after each leaf.",
        )?
        .with_diversity_key("rule:commit-stream");

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare code-first swarm verification",
            budget,
            vec![primary_rule, squeezed_rule, anti_pattern],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let first = draft
            .items
            .first()
            .ok_or_else(|| "expected reserved anti-pattern item".to_owned())?;
        ensure_equal(
            &first.memory_id,
            &memory_id(90),
            "anti-pattern selected before higher-scoring action rules",
        )?;
        ensure_equal(
            &first.section,
            &PackSection::Failures,
            "canonical section remains failures",
        )?;
        ensure_equal(
            &first.selected_in,
            &PackSelectionPhase::AntiPatternFirst,
            "selectedIn marks the reserved slice",
        )?;
        ensure_contains(&first.why, "What NOT to do:", "reserved slice why marker")?;
        ensure_equal(
            &super::context_render_section_key(first),
            &"what_not_to_do",
            "markdown render section key",
        )?;
        ensure_equal(
            &super::context_section_display_name(super::context_render_section_key(first)),
            &"What NOT to do",
            "markdown reserved section label",
        )?;
        ensure(
            draft
                .selection_audit
                .steps
                .first()
                .is_some_and(|step| step.objective_value > 0.0),
            "reserved anti-pattern contributes to the selection audit objective",
        )
    }

    #[test]
    fn anti_pattern_first_empty_candidate_pool_stays_empty() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare code-first swarm verification",
            budget,
            Vec::<PackCandidate>::new(),
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(&draft.items.len(), &0, "empty pool selects no items")?;
        ensure_equal(&draft.omitted.len(), &0, "empty pool omits no items")?;
        ensure_equal(&draft.used_tokens, &0, "empty pool uses no budget")
    }

    #[test]
    fn anti_pattern_first_no_failure_candidates_uses_normal_mmr() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let primary_rule = candidate_in_section(
            11,
            PackSection::ProceduralRules,
            1.00,
            0.80,
            10,
            "Use central batch verification for code-first swarm changes.",
        )?
        .with_diversity_key("rule:central-verify");
        let supporting_evidence = candidate_in_section(
            12,
            PackSection::Evidence,
            0.70,
            0.70,
            10,
            "Central verification caught prior swarm integration failures.",
        )?
        .with_diversity_key("evidence:central-verify");

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare code-first swarm verification",
            budget,
            vec![supporting_evidence, primary_rule],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let first = draft
            .items
            .first()
            .ok_or_else(|| "expected ordinary selected rule".to_owned())?;
        ensure_equal(
            &first.memory_id,
            &memory_id(11),
            "ordinary MMR still chooses the strongest action item",
        )?;
        ensure_equal(
            &first.selected_in,
            &PackSelectionPhase::StrictMmr,
            "no failure candidates means no reserved phase",
        )?;
        ensure(
            draft
                .items
                .iter()
                .all(|item| item.selected_in != PackSelectionPhase::AntiPatternFirst),
            "non-failure candidates never receive the anti-pattern-first marker",
        )?;
        ensure(
            draft
                .items
                .iter()
                .all(|item| !item.why.contains("What NOT to do:")),
            "non-failure candidates are not rewritten as safety warnings",
        )
    }

    #[test]
    fn anti_pattern_first_rejects_below_floor_failure_from_reserved_slice() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let below_floor_failure = candidate_in_section(
            93,
            PackSection::Failures,
            DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR / 2.0,
            0.95,
            8,
            "Do not cargo build locally when the task is unrelated.",
        )?
        .with_diversity_key("anti-pattern:unrelated-local-cargo");
        let primary_rule = candidate_in_section(
            13,
            PackSection::ProceduralRules,
            1.00,
            0.80,
            10,
            "Use central batch verification for code-first swarm changes.",
        )?
        .with_diversity_key("rule:central-verify");

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare code-first swarm verification",
            budget,
            vec![below_floor_failure, primary_rule],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.items.first().map(|item| item.memory_id),
            &Some(memory_id(13)),
            "below-floor safety candidate does not jump ahead of the relevant rule",
        )?;
        ensure(
            draft
                .items
                .iter()
                .filter(|item| item.memory_id == memory_id(93))
                .all(|item| item.selected_in != PackSelectionPhase::AntiPatternFirst),
            "below-floor failure may remain eligible later, but not in the reserved slice",
        )?;
        ensure(
            draft
                .items
                .iter()
                .filter(|item| item.memory_id == memory_id(93))
                .all(|item| !item.why.contains("What NOT to do:")),
            "below-floor failure why text is not rewritten as reserved safety guidance",
        )
    }

    #[test]
    fn anti_pattern_first_accepts_exact_relevance_floor_boundary() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let boundary_failure = candidate_in_section(
            95,
            PackSection::Failures,
            DEFAULT_COVERAGE_FILL_RELEVANCE_FLOOR,
            0.95,
            10,
            "Do not run local Cargo builds during code-first swarm batches.",
        )?
        .with_diversity_key("anti-pattern:local-cargo");
        let primary_rule = candidate_in_section(
            15,
            PackSection::ProceduralRules,
            1.00,
            0.80,
            10,
            "Use central batch verification for code-first swarm changes.",
        )?
        .with_diversity_key("rule:central-verify");

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare code-first swarm verification",
            budget,
            vec![primary_rule, boundary_failure],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let first = draft
            .items
            .first()
            .ok_or_else(|| "expected exact-floor anti-pattern item".to_owned())?;
        ensure_equal(
            &first.memory_id,
            &memory_id(95),
            "exact-floor failure candidate is eligible for the reserved slice",
        )?;
        ensure_equal(
            &first.selected_in,
            &PackSelectionPhase::AntiPatternFirst,
            "exact-floor candidate receives anti-pattern-first marker",
        )?;
        ensure_contains(
            &first.why,
            "What NOT to do:",
            "exact-floor candidate why marker",
        )
    }

    #[test]
    fn anti_pattern_first_respects_failure_section_quota_boundary() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let oversized_failure = candidate_in_section(
            94,
            PackSection::Failures,
            1.00,
            0.95,
            11,
            "Do not run local Cargo builds during code-first swarm batches.",
        )?
        .with_diversity_key("anti-pattern:local-cargo");
        let primary_rule = candidate_in_section(
            14,
            PackSection::ProceduralRules,
            0.90,
            0.80,
            10,
            "Use central batch verification for code-first swarm changes.",
        )?
        .with_diversity_key("rule:central-verify");

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare code-first swarm verification",
            budget,
            vec![oversized_failure, primary_rule],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure(
            draft
                .items
                .iter()
                .all(|item| item.memory_id != memory_id(94)),
            "failure candidate that exceeds the 20 percent balanced slice is not packed",
        )?;
        ensure(
            draft.omitted.iter().any(|omission| {
                omission.memory_id == memory_id(94)
                    && omission.reason == PackOmissionReason::TokenBudgetExceeded
            }),
            "oversized failure is reported as a budget omission",
        )?;
        ensure(
            draft
                .items
                .iter()
                .all(|item| item.selected_in != PackSelectionPhase::AntiPatternFirst),
            "quota-infeasible failure cannot be marked as anti-pattern-first",
        )
    }

    #[test]
    fn anti_pattern_first_can_be_disabled_without_filtering_failures() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let anti_pattern = candidate_in_section(
            92,
            PackSection::Failures,
            0.60,
            0.90,
            10,
            "Do not skip the provenance check before applying a remembered fix.",
        )?
        .with_diversity_key("anti-pattern:provenance");
        let primary_rule = candidate_in_section(
            5,
            PackSection::ProceduralRules,
            1.00,
            0.80,
            15,
            "Check source provenance before applying memory-derived fixes.",
        )?
        .with_diversity_key("rule:provenance");

        let draft = assemble_draft_with_profile_and_options(
            ContextPackProfile::Balanced,
            "apply remembered fix",
            budget,
            vec![anti_pattern, primary_rule],
            PackAssemblyOptions {
                include_anti_pattern_first: false,
                lod_budget_shares: None,
                ..PackAssemblyOptions::default()
            },
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.items.first().map(|item| item.memory_id),
            &Some(memory_id(5)),
            "disabled reserved slice leaves ordinary MMR ranking in charge",
        )?;
        ensure(
            draft
                .items
                .iter()
                .any(|item| item.memory_id == memory_id(92)),
            "disabled reserved slice must not filter failure memories out",
        )?;
        ensure(
            draft
                .items
                .iter()
                .all(|item| item.selected_in != PackSelectionPhase::AntiPatternFirst),
            "disabled reserved slice emits no anti-pattern-first marker",
        )?;
        ensure(
            draft
                .items
                .iter()
                .all(|item| !item.why.contains("What NOT to do:")),
            "disabled reserved slice does not rewrite why text",
        )
    }

    #[test]
    fn anti_pattern_first_applies_to_submodular_profile() -> TestResult {
        let budget = TokenBudget::new(50).map_err(|error| format!("budget rejected: {error:?}"))?;
        let anti_pattern = candidate_in_section(
            91,
            PackSection::Failures,
            0.55,
            0.90,
            10,
            "Do not bypass provenance checks when applying prior fixes.",
        )?
        .with_diversity_key("risk:provenance-bypass");
        let action_rule = candidate_in_section(
            3,
            PackSection::ProceduralRules,
            1.00,
            0.85,
            10,
            "Inspect provenance before trusting memory-derived fixes.",
        )?
        .with_diversity_key("rule:provenance");
        let evidence = candidate_in_section(
            4,
            PackSection::Evidence,
            0.80,
            0.75,
            10,
            "A prior fix regressed when provenance was not checked.",
        )?
        .with_diversity_key("evidence:provenance");

        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "apply memory-derived fix",
            budget,
            vec![action_rule, evidence, anti_pattern],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let first = draft
            .items
            .first()
            .ok_or_else(|| "expected reserved submodular anti-pattern item".to_owned())?;
        ensure_equal(
            &draft.selection_audit.objective,
            &PackSelectionObjective::FacilityLocation,
            "submodular objective retained",
        )?;
        ensure_equal(
            &first.memory_id,
            &memory_id(91),
            "submodular profile reserves the relevant failure item first",
        )?;
        ensure_equal(
            &first.selected_in,
            &PackSelectionPhase::AntiPatternFirst,
            "submodular selectedIn marker",
        )?;
        ensure_contains(
            &first.why,
            "reserved anti-pattern/failure/risk slice",
            "submodular why marker",
        )
    }

    #[test]
    fn lod_budget_shares_default_to_seventy_twenty_ten() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let limits = super::PackLodBudgetShares::default_70_20_10().limits(budget);

        ensure_equal(&limits.full, &700, "full tier share")?;
        ensure_equal(
            &limits.truncated_preview,
            &200,
            "truncated preview tier share",
        )?;
        ensure_equal(&limits.link_only, &100, "link-only tier share")
    }

    #[test]
    fn lod_budget_shares_all_zero_degrade_to_full_budget() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let limits = super::PackLodBudgetShares::new(0, 0, 0).limits(budget);

        ensure_equal(
            &limits.full,
            &1_000,
            "all-zero shares should keep full-tier selection available",
        )?;
        ensure_equal(
            &limits.truncated_preview,
            &0,
            "all-zero shares should not synthesize preview capacity",
        )?;
        ensure_equal(
            &limits.link_only,
            &0,
            "all-zero shares should not synthesize link-only capacity",
        )
    }

    #[test]
    fn lod_candidate_plan_fills_full_preview_and_link_tiers() -> TestResult {
        let budget =
            TokenBudget::new(300).map_err(|error| format!("budget rejected: {error:?}"))?;
        let quotas = SectionQuotas::unlimited();
        let section_usage = super::SectionTokenUsage::default();
        let mut lod_usage =
            super::PackLodBudgetState::from_options(PackAssemblyOptions::default(), budget);

        let full_candidate = candidate_with_content(1, 1.0, 0.8, 210, "full detail survives")?;
        let full_plan = super::pack_lod_candidate_plan(
            &full_candidate,
            0,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
        .ok_or_else(|| "expected full-tier candidate plan".to_string())?;
        ensure_equal(
            &full_plan.tier,
            &super::PackLodTier::Full,
            "first candidate consumes full tier",
        )?;
        ensure_equal(
            &full_plan.candidate.content,
            &full_candidate.content,
            "full tier preserves content",
        )?;
        lod_usage.add(full_plan.tier, full_plan.candidate.estimated_tokens);

        let preview_source = repeated_lod_content("preview", 160);
        let preview_candidate = candidate_with_content(2, 0.9, 0.8, 200, preview_source.clone())?;
        let preview_plan = super::pack_lod_candidate_plan(
            &preview_candidate,
            210,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
        .ok_or_else(|| "expected preview-tier candidate plan".to_string())?;
        ensure_equal(
            &preview_plan.tier,
            &super::PackLodTier::TruncatedPreview,
            "full-tier overflow falls back to preview tier",
        )?;
        ensure(
            preview_plan.candidate.estimated_tokens <= 60,
            "preview tier must stay within the 20% share",
        )?;
        ensure(
            preview_plan.candidate.content.ends_with(" ..."),
            "preview tier should emit deterministic truncated content",
        )?;
        ensure(
            preview_plan.candidate.content != preview_source,
            "preview tier must not preserve full content",
        )?;
        lod_usage.add(preview_plan.tier, preview_plan.candidate.estimated_tokens);
        let preview_remaining = lod_usage.remaining(super::PackLodTier::TruncatedPreview);
        lod_usage.add(super::PackLodTier::TruncatedPreview, preview_remaining);

        let link_candidate =
            candidate_with_content(3, 0.8, 0.8, 200, repeated_lod_content("link", 160))?;
        let link_plan = super::pack_lod_candidate_plan(
            &link_candidate,
            270,
            budget,
            &quotas,
            &section_usage,
            &lod_usage,
        )
        .ok_or_else(|| "expected link-only candidate plan".to_string())?;
        ensure_equal(
            &link_plan.tier,
            &super::PackLodTier::LinkOnly,
            "preview overflow falls back to link-only tier",
        )?;
        ensure(
            link_plan.candidate.estimated_tokens <= 30,
            "link-only tier must stay within the 10% share",
        )?;
        ensure_contains(
            &link_plan.candidate.content,
            &link_candidate.memory_id.to_string(),
            "link-only tier points at the source memory",
        )?;
        ensure(
            !link_plan.candidate.content.contains("file://AGENTS.md"),
            "link-only tier should not duplicate provenance URI into content",
        )
    }

    #[test]
    fn lod_preview_is_deterministic_extractive_and_off_by_one_free() -> TestResult {
        // bd-1n0np.5.2: the truncated-preview tier must be a DETERMINISTIC,
        // EXTRACTIVE (never generated/abstractive) word-prefix of the source,
        // and its token estimate must never exceed the tier limit (off-by-one-
        // free accounting at the budget boundary so the pack hash stays stable).
        let source = (0..48)
            .map(|index| format!("w{index}"))
            .collect::<Vec<_>>()
            .join(" ");
        let source_words = source.split_whitespace().collect::<Vec<_>>();

        for limit in [3_u32, 5, 8, 13, 21] {
            let first = super::truncated_preview_content(&source, limit);
            let second = super::truncated_preview_content(&source, limit);
            ensure_equal(&first, &second, "preview must be deterministic across runs")?;

            let Some(preview) = first else {
                continue;
            };
            // Off-by-one-free: the estimate never exceeds the limit it was given.
            ensure(
                super::estimate_tokens_default(&preview) <= limit,
                "preview token estimate must stay within the tier limit",
            )?;
            // Extractive: stripping the deterministic ellipsis marker leaves a
            // strict word-prefix of the source (no synthesized tokens).
            let body = preview.strip_suffix(" ...").unwrap_or(&preview);
            let preview_words = body.split_whitespace().collect::<Vec<_>>();
            ensure(
                preview_words.len() <= source_words.len()
                    && preview_words[..] == source_words[..preview_words.len()],
                "preview must be a strict word-prefix of the source (extractive, not generated)",
            )?;
        }
        Ok(())
    }

    #[test]
    fn lod_link_only_candidate_is_deterministic_and_within_budget() -> TestResult {
        // bd-1n0np.5.2/5.3: the link-only peripheral-index tier must be a
        // deterministic, budget-bounded stub that points at the source memory
        // and drops the full body — the data the 5.3 peripheral-vision index
        // renders so an agent can drill in via `ee memory show <id>`.
        let candidate =
            candidate_with_content(7, 0.9, 0.8, 500, repeated_lod_content("body", 200))?;
        let memory_id = candidate.memory_id.to_string();

        for limit in [4_u32, 8, 32, 64] {
            let first = super::link_only_lod_candidate(&candidate, limit);
            let second = super::link_only_lod_candidate(&candidate, limit);
            ensure_equal(&first, &second, "link-only rendering must be deterministic")?;

            let Some(link) = first else {
                continue;
            };
            ensure(
                super::estimate_tokens_default(&link.content) <= limit,
                "link-only content must stay within the tier limit",
            )?;
            ensure(
                link.content.contains(&memory_id),
                "link-only content must point at the source memory id",
            )?;
            ensure(
                !link.content.contains("body0"),
                "link-only tier must drop the full body content",
            )?;
        }
        Ok(())
    }

    #[test]
    fn link_only_pack_items_classify_for_peripheral_index() -> TestResult {
        // bd-1n0np.5.3: the markdown renderer routes link-only LOD items to the
        // peripheral index by recognizing their deterministic stub content.
        let candidate = candidate_with_content(11, 0.9, 0.8, 5, "full body content stays inline")?;
        let memory_id = candidate.memory_id;
        let full_item = super::PackDraftItem::from_selected_candidate(
            1,
            candidate,
            Vec::new(),
            super::PackSelectionPhase::StrictMmr,
        );
        ensure(
            !super::is_link_only_pack_item(&full_item),
            "a full-content item must not be classified as peripheral",
        )?;

        let mut prefixed_stub = full_item.clone();
        prefixed_stub.content = format!("Memory {memory_id}");
        ensure(
            super::is_link_only_pack_item(&prefixed_stub),
            "the 'Memory <id>' link stub must classify as peripheral",
        )?;

        let mut bare_stub = full_item;
        bare_stub.content = memory_id.to_string();
        ensure(
            super::is_link_only_pack_item(&bare_stub),
            "the bare-id link stub must classify as peripheral",
        )?;
        Ok(())
    }

    #[test]
    fn markdown_render_routes_link_only_items_to_peripheral_index() -> TestResult {
        // bd-1n0np.5.3/5.4: render-level proof that link-only LOD items land in
        // the markdown peripheral index (not inline), and that packs without
        // link-only items emit no peripheral section (golden-safety guard).
        let full = candidate_with_content(20, 0.95, 0.8, 30, "full body that stays inline")?;
        let stub = candidate_with_content(21, 0.85, 0.8, 5, "placeholder body")?;
        let stub_id = stub.memory_id;
        let mut draft = draft_from_candidates(vec![full, stub])?;
        if let Some(item) = draft
            .items
            .iter_mut()
            .find(|item| item.memory_id == stub_id)
        {
            item.content = format!("Memory {stub_id}");
        }
        let request = ContextRequest::new(ContextRequestInput {
            query: "lod peripheral render".to_string(),
            profile: Some(ContextPackProfile::Balanced),
            max_tokens: Some(1_000),
            candidate_pool: Some(20),
            max_results: None,
            sections: Vec::new(),
        })
        .map_err(|error| format!("request rejected: {error:?}"))?;

        let markdown = render_context_markdown_with_analysis(&request, &draft, &[], &[], &[], None);
        ensure(
            markdown.contains("## Peripheral Index"),
            "a link-only item must produce a peripheral index section",
        )?;
        ensure(
            markdown.contains(&stub_id.to_string()),
            "the peripheral index must list the link-only memory id",
        )?;
        ensure(
            !markdown.contains(&format!("Memory {stub_id}")),
            "the link-only stub body must not render inline; only the id appears in the index",
        )?;

        let plain = draft_from_candidates(vec![candidate_with_content(
            22,
            0.9,
            0.8,
            20,
            "plain inline content",
        )?])?;
        let plain_markdown =
            render_context_markdown_with_analysis(&request, &plain, &[], &[], &[], None);
        ensure(
            !plain_markdown.contains("## Peripheral Index"),
            "packs without link-only items must not emit a peripheral index",
        )?;
        Ok(())
    }

    #[test]
    fn preview_lod_respects_candidate_token_estimate_when_heuristic_is_short() -> TestResult {
        let candidate = candidate_with_content(
            4,
            0.9,
            0.8,
            200,
            "compact wording whose authoritative estimate is still oversized",
        )?;

        let preview =
            super::candidate_for_lod_tier(&candidate, super::PackLodTier::TruncatedPreview, 100)
                .ok_or_else(|| "expected truncated preview candidate".to_string())?;

        ensure(
            preview.content.ends_with(" ..."),
            "preview tier must visibly truncate when authoritative token estimate is over limit",
        )?;
        ensure(
            preview.content != candidate.content,
            "preview tier must not preserve complete oversized content",
        )?;
        ensure(
            preview.estimated_tokens <= 100,
            "preview stays within tier limit after truncation",
        )
    }

    #[test]
    fn preview_lod_rejects_single_word_oversized_content() -> TestResult {
        let candidate = candidate_with_content(5, 0.9, 0.8, 200, "singleword")?;

        let preview =
            super::candidate_for_lod_tier(&candidate, super::PackLodTier::TruncatedPreview, 100);

        ensure(
            preview.is_none(),
            "single-word oversized content should fall through to link-only instead of preview",
        )
    }

    #[test]
    fn assemble_draft_default_lod_renders_full_preview_and_link_items() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let procedural_content = repeated_lod_content("procedural-full", 48);
        let decision_content = repeated_lod_content("decision-full", 32);
        let failure_content = repeated_lod_content("failure-full", 32);
        let preview_source = repeated_lod_content("preview", 160);
        let link_source = "link".repeat(1_000);
        let preview_memory_id = memory_id(4);
        let link_memory_id = memory_id(5);

        let draft = assemble_draft(
            "prepare release with LOD",
            budget,
            vec![
                candidate_in_section(
                    1,
                    PackSection::ProceduralRules,
                    1.0,
                    0.9,
                    300,
                    procedural_content.clone(),
                )?,
                candidate_in_section(
                    2,
                    PackSection::Decisions,
                    0.99,
                    0.9,
                    200,
                    decision_content.clone(),
                )?,
                candidate_in_section(
                    3,
                    PackSection::Failures,
                    0.98,
                    0.9,
                    200,
                    failure_content.clone(),
                )?,
                candidate_in_section(
                    4,
                    PackSection::Evidence,
                    0.4,
                    0.4,
                    200,
                    preview_source.clone(),
                )?,
                candidate_in_section(5, PackSection::Artifacts, 0.3, 0.3, 150, link_source)?,
            ],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.items.len(),
            &5,
            "LOD assembly selected every feasible tier",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(1))?.content,
            &procedural_content,
            "procedural item stays full detail",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(2))?.content,
            &decision_content,
            "decision item stays full detail",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(3))?.content,
            &failure_content,
            "failure item stays full detail",
        )?;
        let preview_item = selected_item_for_memory(&draft, preview_memory_id)?;
        ensure(
            preview_item.content.ends_with(" ..."),
            "preview item becomes a deterministic preview",
        )?;
        ensure(
            preview_item.content != preview_source,
            "preview item must not retain full source content",
        )?;
        ensure(
            preview_item.estimated_tokens <= 200,
            "preview item stays within the 20% budget share",
        )?;
        let link_item = selected_item_for_memory(&draft, link_memory_id)?;
        ensure_contains(
            &link_item.content,
            &link_memory_id.to_string(),
            "link item becomes a link-only pointer",
        )?;
        ensure(
            link_item.estimated_tokens <= 100,
            "link-only item stays within the 10% budget share",
        )
    }

    #[test]
    fn submodular_draft_default_lod_renders_full_preview_and_link_items() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let evidence_content = repeated_lod_content("submodular-evidence", 40);
        let procedural_content = repeated_lod_content("submodular-procedural", 32);
        let decision_content = repeated_lod_content("submodular-decision", 32);
        let artifact_content = repeated_lod_content("submodular-artifact", 8);
        let preview_source = repeated_lod_content("submodular-preview", 160);
        let link_source = "submodular-link".repeat(1_000);
        let preview_memory_id = memory_id(14);
        let link_memory_id = memory_id(15);

        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release with facility LOD",
            budget,
            vec![
                candidate_in_section(
                    10,
                    PackSection::Evidence,
                    1.0,
                    0.9,
                    250,
                    evidence_content.clone(),
                )?,
                candidate_in_section(
                    11,
                    PackSection::ProceduralRules,
                    0.99,
                    0.9,
                    200,
                    procedural_content.clone(),
                )?,
                candidate_in_section(
                    12,
                    PackSection::Decisions,
                    0.98,
                    0.9,
                    200,
                    decision_content.clone(),
                )?,
                candidate_in_section(
                    13,
                    PackSection::Artifacts,
                    0.97,
                    0.9,
                    50,
                    artifact_content.clone(),
                )?,
                // The anti-pattern-first phase owns Failures/Risk, so make
                // the original failure larger than the entire 70% full
                // tier. Its reserved selection must therefore use the 20%
                // preview tier rather than consume full-share tokens. The
                // four ordinary full candidates then consume exactly 70%,
                // leaving the final candidate for the 10% link tier.
                candidate_in_section(
                    14,
                    PackSection::Failures,
                    0.3,
                    0.3,
                    701,
                    preview_source.clone(),
                )?,
                candidate_in_section(15, PackSection::Artifacts, 0.2, 0.2, 200, link_source)?,
            ],
        )
        .map_err(|error| format!("submodular draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.items.len(),
            &6,
            "submodular LOD assembly selected every feasible tier",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(10))?.content,
            &evidence_content,
            "evidence item stays full detail",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(11))?.content,
            &procedural_content,
            "procedural item stays full detail",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(12))?.content,
            &decision_content,
            "decision item stays full detail",
        )?;
        ensure_equal(
            &selected_item_for_memory(&draft, memory_id(13))?.content,
            &artifact_content,
            "artifact item stays full detail",
        )?;
        let preview_item = selected_item_for_memory(&draft, preview_memory_id)?;
        ensure(
            preview_item.content.ends_with(" ..."),
            "submodular preview item becomes a deterministic preview",
        )?;
        ensure(
            preview_item.content != preview_source,
            "submodular preview item must not retain full source content",
        )?;
        ensure(
            preview_item.estimated_tokens <= 200,
            "submodular preview item stays within the 20% budget share",
        )?;
        let link_item = selected_item_for_memory(&draft, link_memory_id)?;
        ensure_contains(
            &link_item.content,
            &link_memory_id.to_string(),
            "submodular link item becomes a link-only pointer",
        )?;
        ensure(
            link_item.estimated_tokens <= 100,
            "submodular link item stays within the 10% budget share",
        )
    }

    #[test]
    fn mmr_similarity_cache_matches_full_selected_scan() -> TestResult {
        let selected = [
            candidate_with_content(1, 1.0, 0.5, 10, "Run cargo fmt --check before release.")?
                .with_diversity_key("release-formatting"),
            candidate_with_content(2, 0.8, 0.5, 10, "Verify release checksums.")?
                .with_diversity_key("release-checks"),
        ];
        let selected_signatures = selected
            .iter()
            .map(CandidateSignature::from)
            .collect::<Vec<_>>();
        let candidates = vec![
            candidate_with_content(3, 0.99, 0.5, 10, "Run cargo fmt --check before release.")?
                .with_diversity_key("release-formatting"),
            candidate_with_content(4, 0.85, 0.5, 10, "Publish release notes.")?
                .with_diversity_key("release-notes"),
            candidate_with_content(5, 0.7, 0.5, 10, "Verify release checksums.")?
                .with_diversity_key("release-checks"),
        ]
        .into_iter()
        .map(super::MmrCandidate::from)
        .collect::<Vec<_>>();
        let mut cached_similarities = vec![0.0_f32; candidates.len()];
        for selected_signature in &selected_signatures {
            super::update_mmr_max_similarities(
                &mut cached_similarities,
                &candidates,
                selected_signature,
            );
        }

        for (index, candidate) in candidates.iter().enumerate() {
            let full_similarity =
                super::max_selected_similarity(&candidate.signature, &selected_signatures);
            ensure_close(
                cached_similarities[index],
                full_similarity,
                "cached max similarity matches full selected scan",
            )?;
            ensure_close(
                super::strict_mmr_marginal_gain_from_similarity(
                    candidate,
                    cached_similarities[index],
                ),
                super::strict_mmr_marginal_gain(candidate, &selected_signatures),
                "cached marginal gain matches full selected scan",
            )?;
        }

        let cached_index = super::select_next_candidate_index(&candidates, &cached_similarities);
        let mut full_scan_index = 0_usize;
        let mut full_scan_score =
            super::strict_mmr_marginal_gain(&candidates[0], &selected_signatures);
        for (candidate_index, candidate) in candidates.iter().enumerate().skip(1) {
            let score = super::strict_mmr_marginal_gain(candidate, &selected_signatures);
            let ordering = full_scan_score.total_cmp(&score).then_with(|| {
                super::compare_candidates(
                    &candidate.candidate,
                    &candidates[full_scan_index].candidate,
                )
            });
            if ordering == Ordering::Less {
                full_scan_index = candidate_index;
                full_scan_score = score;
            }
        }

        ensure_equal(
            &cached_index,
            &full_scan_index,
            "cached selector preserves full-scan MMR ordering",
        )
    }

    #[test]
    fn coverage_fill_respects_relevance_floor() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let shared_content = "Run cargo fmt --check before release.";
        let first = candidate_with_content(1, 1.0, 0.5, 10, shared_content)?;
        let below_floor_duplicate = candidate_with_content(2, 0.04, 0.5, 10, shared_content)?;

        let draft = assemble_draft(
            "prepare release",
            budget,
            vec![below_floor_duplicate, first],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(&draft.items.len(), &1, "below-floor duplicate not filled")?;
        ensure_equal(&draft.omitted.len(), &1, "below-floor duplicate skipped")?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.memory_id),
            &Some(memory_id(2)),
            "below-floor duplicate id",
        )?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.reason),
            &Some(PackOmissionReason::BelowRelevanceFloor),
            "below-floor omission reason",
        )?;
        ensure_equal(
            &draft
                .omitted
                .first()
                .map(|omission| omission.reason.as_str()),
            &Some("below_relevance_floor"),
            "below-floor omission reason wire name",
        )?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.rejected_at),
            &Some(PackRejectionStage::CandidateFilter),
            "below-floor rejection stage",
        )
    }

    #[test]
    fn mmr_does_not_drop_unrelated_memories_sharing_diversity_key() -> TestResult {
        // Bug: eidetic_engine_cli-6cjh
        // Two unrelated memories with the same diversity_key but different content
        // should NOT be considered redundant. The old code dropped the second one
        // just because they shared a coarse tag like "formatting".
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;

        // Same diversity_key, but completely different content
        let fmt_rule = candidate_with_content(1, 1.0, 0.5, 10, "Run cargo fmt before release.")?
            .with_diversity_key("formatting");
        let rustfmt_config =
            candidate_with_content(2, 0.9, 0.5, 10, "Use rustfmt.toml for configuration.")?
                .with_diversity_key("formatting");
        let lint_rule =
            candidate_with_content(3, 0.8, 0.5, 10, "Run clippy with warnings as errors.")?
                .with_diversity_key("linting");

        let draft = assemble_draft(
            "prepare release",
            budget,
            vec![fmt_rule, rustfmt_config, lint_rule],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        // All three should be selected because they have different content
        // (order may vary due to MMR similarity penalties, but none should be dropped)
        let mut ids: Vec<MemoryId> = draft.items.iter().map(|item| item.memory_id).collect();
        ids.sort();
        let mut expected = vec![memory_id(1), memory_id(2), memory_id(3)];
        expected.sort();
        ensure_equal(
            &ids,
            &expected,
            "unrelated memories with same diversity_key should NOT be dropped",
        )?;
        ensure_equal(&draft.used_tokens, &30, "all three selected")?;
        ensure_equal(&draft.omitted.len(), &0, "no redundant candidates")
    }

    #[test]
    fn mmr_precomputes_candidate_terms_once() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let candidates = (1_u128..=8)
            .map(|seed| {
                let relevance = 1.0 - (seed as f32 * 0.01);
                candidate_with_content(
                    seed,
                    relevance,
                    0.5,
                    10,
                    format!("release workflow step {seed} cargo fmt clippy shared term"),
                )
            })
            .collect::<Result<Vec<_>, _>>()?;

        super::reset_normalized_terms_call_count();
        let draft = assemble_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates,
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.selection_audit.candidate_count,
            &8,
            "candidate count",
        )?;
        ensure_equal(&draft.items.len(), &8, "all candidates fit the budget")?;
        ensure_equal(
            &super::normalized_terms_call_count(),
            &8,
            "MMR tokenizes once per candidate instead of during pairwise similarity checks",
        )
    }

    #[test]
    fn submodular_profile_precomputes_candidate_terms_once() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let candidates = (1_u128..=8)
            .map(|seed| {
                let relevance = 1.0 - (seed as f32 * 0.01);
                candidate_with_content(
                    seed,
                    relevance,
                    0.5,
                    10,
                    format!("release workflow step {seed} facility location shared term"),
                )
            })
            .collect::<Result<Vec<_>, _>>()?;

        super::reset_normalized_terms_call_count();
        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            candidates,
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.selection_audit.candidate_count,
            &8,
            "candidate count",
        )?;
        ensure_equal(&draft.items.len(), &8, "all candidates fit the budget")?;
        ensure_equal(
            &super::normalized_terms_call_count(),
            &8,
            "submodular facility-location tokenizes once per candidate instead of during each universe comparison",
        )
    }

    #[test]
    fn candidate_similarity_uses_content_not_just_diversity_key() -> TestResult {
        // Bug: eidetic_engine_cli-6cjh
        // Verify candidate_similarity returns < 1.0 when diversity_key matches
        // but content differs.
        let first = candidate_with_content(1, 1.0, 0.5, 10, "Run cargo fmt before release.")?
            .with_diversity_key("formatting");
        let unrelated =
            candidate_with_content(2, 0.9, 0.5, 10, "Use rustfmt.toml for configuration.")?
                .with_diversity_key("formatting");

        let first_sig = CandidateSignature::from(&first);
        let similarity = candidate_similarity(&unrelated, &first_sig);

        // Matching diversity_key with different content should NOT return 1.0
        ensure(
            similarity < 1.0,
            format!("similarity should be < 1.0 for different content, got {similarity}"),
        )?;
        // Should return boosted content overlap (around 0.5 since there's some word overlap)
        ensure(
            similarity >= 0.5,
            format!("similarity should be >= 0.5 for matching diversity_key, got {similarity}"),
        )
    }

    #[test]
    fn facility_similarity_diversity_key_floor_constant_value() -> TestResult {
        // Pin the public constant. The greedy facility-location picker depends
        // on this value to dampen diversity-key collisions; if it ever drifts
        // we want a single failing assertion to surface that intentional
        // change instead of silently shifting the selection mix.
        ensure(
            (FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR - 0.85).abs() < f32::EPSILON,
            format!(
                "diversity_key floor must be 0.85, got {FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR}"
            ),
        )
    }

    #[test]
    fn facility_similarity_applies_diversity_key_floor() -> TestResult {
        // Disjoint texts -> Jaccard overlap is 0; the diversity_key match
        // must lift the result to exactly the documented floor.
        let first = candidate_with_content(1, 1.0, 0.5, 10, "alpha bravo charlie")?
            .with_diversity_key("bucket-a");
        let unrelated = candidate_with_content(2, 0.9, 0.5, 10, "delta echo foxtrot")?
            .with_diversity_key("bucket-a");

        let first_sig = CandidateSignature::from(&first);
        let similarity = facility_similarity(&unrelated, &first_sig);

        ensure(
            (similarity - FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR).abs() < f32::EPSILON,
            format!(
                "matching diversity_key with disjoint content should land on the {FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR} floor, got {similarity}"
            ),
        )
    }

    #[test]
    fn facility_similarity_ignores_floor_without_diversity_key_match() -> TestResult {
        // Different (or absent) diversity_key buckets must skip the floor and
        // fall back to plain Jaccard overlap. With disjoint texts that is 0.
        let first = candidate_with_content(1, 1.0, 0.5, 10, "alpha bravo charlie")?
            .with_diversity_key("bucket-a");
        let other = candidate_with_content(2, 0.9, 0.5, 10, "delta echo foxtrot")?
            .with_diversity_key("bucket-b");

        let first_sig = CandidateSignature::from(&first);
        let similarity = facility_similarity(&other, &first_sig);

        ensure(
            similarity < FACILITY_LOCATION_DIVERSITY_KEY_SIMILARITY_FLOOR,
            format!("non-matching diversity_keys must not trigger the floor, got {similarity}"),
        )
    }

    #[test]
    fn content_overlap_similarity_uses_jaccard_cardinality() -> TestResult {
        let left = super::normalized_terms("cargo fmt release workflow");
        let right = super::normalized_terms("cargo clippy release workflow");

        let similarity = super::content_overlap_similarity_terms(&left, &right);
        let expected = 3.0_f32 / 5.0_f32;

        ensure(
            (similarity - expected).abs() < f32::EPSILON,
            format!("Jaccard similarity should be {expected}, got {similarity}"),
        )
    }

    #[test]
    fn facility_location_selector_skips_zero_token_candidates() -> TestResult {
        let mut zero_token_candidate =
            candidate_with_content(1, 1.0, 0.5, 10, "alpha bravo charlie")?;
        zero_token_candidate.estimated_tokens = 0;

        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let quotas = super::SectionQuotas::for_profile(ContextPackProfile::Submodular, 100);
        let universe = vec![super::FacilityCandidateProfile::from(zero_token_candidate)];
        let current_coverages = vec![0.0_f32];
        let similarity_cache = super::FacilitySimilarityCache::new(&universe);
        let mut selector =
            super::FacilitySelectionQueue::new(&universe, &current_coverages, &similarity_cache);
        let lod_usage =
            super::PackLodBudgetState::from_options(PackAssemblyOptions::default(), budget);

        let selection = selector.select(
            &universe,
            &current_coverages,
            &similarity_cache,
            0,
            budget,
            &quotas,
            &super::SectionTokenUsage::default(),
            &lod_usage,
        );
        ensure(
            selection.is_none(),
            "selector should skip zero-token candidates instead of computing infinite gain ratios",
        )
    }

    #[test]
    fn facility_location_selector_ranks_lod_candidates_by_rendered_token_cost() -> TestResult {
        let oversized_high_value = candidate_with_content(1, 1.0, 1.0, 900, "singlewordoversized")?;
        let compact_lower_value =
            candidate_with_content(2, 0.2, 0.2, 20, "compact lower value memory")?;
        let universe = vec![
            super::FacilityCandidateProfile::from(oversized_high_value),
            super::FacilityCandidateProfile::from(compact_lower_value),
        ];
        let current_coverages = vec![0.0_f32; universe.len()];
        let similarity_cache = super::FacilitySimilarityCache::new(&universe);
        let mut selector =
            super::FacilitySelectionQueue::new(&universe, &current_coverages, &similarity_cache);
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let quotas = super::SectionQuotas::unlimited();
        let lod_usage =
            super::PackLodBudgetState::from_options(PackAssemblyOptions::default(), budget);

        let (profile_index, _) = selector
            .select(
                &universe,
                &current_coverages,
                &similarity_cache,
                0,
                budget,
                &quotas,
                &super::SectionTokenUsage::default(),
                &lod_usage,
            )
            .ok_or_else(|| "expected selector to admit a candidate".to_string())?;

        ensure_equal(
            &profile_index,
            &0,
            "LOD selector should rank by compressed link-only token cost, not full source cost",
        )
    }

    #[test]
    fn facility_candidate_feasibility_uses_cached_section_usage() -> TestResult {
        let selected = candidate_in_section(
            1,
            PackSection::ProceduralRules,
            1.0,
            0.5,
            60,
            "selected procedural release rule",
        )?;
        let blocked_same_section = candidate_in_section(
            2,
            PackSection::ProceduralRules,
            0.9,
            0.5,
            50,
            "second procedural release rule",
        )?;
        let allowed_other_section = candidate_in_section(
            3,
            PackSection::Evidence,
            0.8,
            0.5,
            50,
            "evidence release note",
        )?;
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let quotas = SectionQuotas::new(
            SectionQuota::capped(100),
            SectionQuota::unlimited(),
            SectionQuota::unlimited(),
            SectionQuota::unlimited(),
            SectionQuota::unlimited(),
        );
        let mut section_usage = super::SectionTokenUsage::default();
        section_usage.add_candidate(&selected);

        ensure(
            !super::facility_candidate_is_feasible(
                &blocked_same_section,
                selected.estimated_tokens,
                budget,
                &quotas,
                &section_usage,
            ),
            "cached same-section usage should enforce quota without scanning selected items",
        )?;
        ensure(
            super::facility_candidate_is_feasible(
                &allowed_other_section,
                selected.estimated_tokens,
                budget,
                &quotas,
                &section_usage,
            ),
            "cached usage for one section must not consume another section's quota",
        )
    }

    #[test]
    fn why_not_selected_reports_token_budget_frontier_without_memory_body() -> TestResult {
        let selected = candidate_with_content(1, 1.0, 0.5, 20, "Run cargo fmt before release.")?;
        let target = candidate_with_content(
            2,
            0.95,
            0.5,
            20,
            "Secret diagnostic api_key=why-not-fixture should never render.",
        )?;
        let budget = TokenBudget::new(60).map_err(|error| format!("budget rejected: {error:?}"))?;
        let report = super::explain_why_not_selected(
            super::WhyNotSelectedInput::new(
                "prepare release",
                target.clone(),
                budget,
                ContextPackProfile::Compact,
                vec![selected, target],
            )
            .with_options(classic_pack_options()),
        )
        .map_err(|error| format!("why-not rejected: {error:?}"))?;

        ensure_equal(
            &report.schema,
            &super::WHY_NOT_SELECTED_SCHEMA_V1,
            "why-not schema",
        )?;
        ensure_equal(
            &report.primary_reason.as_str(),
            &"omitted_by_token_budget",
            "primary reason",
        )?;
        ensure(
            report.token_budget_frontier.required_additional_tokens > 0,
            "token frontier should name the additional budget",
        )?;
        ensure(
            report
                .counterfactual_hints
                .iter()
                .any(|hint| hint.kind == "raise_token_budget"),
            "token-budget omission should include a budget hint",
        )?;
        let json = serde_json::to_string(&report).map_err(|error| error.to_string())?;
        ensure(
            !json.contains("why-not-fixture"),
            "why-not report must not serialize raw target memory content",
        )
    }

    #[test]
    fn why_not_selected_reports_below_score_floor() -> TestResult {
        let selected = candidate_with_content(1, 1.0, 0.5, 10, "identical release checklist")?;
        let target = candidate_with_content(2, 0.01, 0.5, 10, "identical release checklist")?;
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;

        let report = super::explain_why_not_selected(super::WhyNotSelectedInput::new(
            "prepare release",
            target.clone(),
            budget,
            ContextPackProfile::Balanced,
            vec![selected, target],
        ))
        .map_err(|error| format!("why-not rejected: {error:?}"))?;

        ensure_equal(
            &report.primary_reason.as_str(),
            &"omitted_by_score_floor",
            "score-floor reason",
        )?;
        ensure(
            report
                .filters_applied
                .iter()
                .any(|filter| filter.code == "below_relevance_floor" && !filter.passed),
            "score-floor filter should be recorded",
        )
    }

    #[test]
    fn why_not_selected_reports_scope_redaction_and_validity_exclusions() -> TestResult {
        let target = candidate_with_content(10, 0.8, 0.5, 10, "scoped memory")?;
        let cases = [
            (
                super::WhyNotSelectionExclusionKind::Scope,
                "scope_mismatch",
                "excluded_by_scope",
            ),
            (
                super::WhyNotSelectionExclusionKind::Redaction,
                "redaction_level_blocks_memory",
                "excluded_by_redaction",
            ),
            (
                super::WhyNotSelectionExclusionKind::ValidityWindow,
                "validity_window_expired",
                "excluded_by_validity_window",
            ),
        ];

        for (kind, code, reason) in cases {
            let budget =
                TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
            let input = super::WhyNotSelectedInput::new(
                "prepare release",
                target.clone(),
                budget,
                ContextPackProfile::Balanced,
                Vec::new(),
            )
            .with_exclusions(vec![super::WhyNotSelectionExclusion::new(
                kind,
                code,
                "candidate blocked before selection",
                Some("adjust context filters".to_string()),
            )]);
            let report = super::explain_why_not_selected(input)
                .map_err(|error| format!("why-not rejected: {error:?}"))?;

            ensure_equal(
                &report.primary_reason.as_str(),
                &reason,
                "exclusion primary reason",
            )?;
            ensure_equal(
                &report.redaction_scope_exclusions[0].code.as_str(),
                &code,
                "exclusion code",
            )?;
        }
        Ok(())
    }

    #[test]
    fn why_not_selected_reports_degraded_index_miss() -> TestResult {
        let target = candidate_with_content(20, 0.8, 0.5, 10, "degraded index target")?;
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let report = super::explain_why_not_selected(
            super::WhyNotSelectedInput::new(
                "prepare release",
                target,
                budget,
                ContextPackProfile::Balanced,
                Vec::new(),
            )
            .with_degraded(vec![super::WhyNotSelectionDegradation::new(
                "index_stale",
                "warning",
                "search index was stale during retrieval",
                Some("ee index rebuild --workspace .".to_string()),
            )]),
        )
        .map_err(|error| format!("why-not rejected: {error:?}"))?;

        ensure_equal(
            &report.primary_reason.as_str(),
            &"not_retrieved_due_to_degraded_index",
            "degraded-index primary reason",
        )?;
        ensure(
            report
                .counterfactual_hints
                .iter()
                .any(|hint| hint.kind == "repair_degraded_index"),
            "degraded index miss should include repair hint",
        )
    }

    #[test]
    fn coverage_gap_reports_missing_kinds_for_thin_release_pack() -> TestResult {
        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            TokenBudget::new(200).map_err(|error| format!("budget rejected: {error:?}"))?,
            vec![candidate_with_content(
                1,
                0.95,
                0.5,
                20,
                "Run cargo fmt before editing code.",
            )?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let report = super::explain_coverage_gap("prepare release", &draft);
        let missing = report
            .missing_kinds
            .iter()
            .map(|gap| gap.kind.as_str())
            .collect::<Vec<_>>();
        let templates = report
            .capture_templates
            .iter()
            .map(|template| template.kind.as_str())
            .collect::<Vec<_>>();

        ensure_equal(
            &report.schema,
            &super::COVERAGE_GAP_SCHEMA_V1,
            "coverage gap schema",
        )?;
        ensure_equal(
            &report.posture.as_str(),
            &"capture_required",
            "thin release pack posture",
        )?;
        ensure(
            missing.contains(&"release_rule")
                && missing.contains(&"decision")
                && missing.contains(&"anti_pattern"),
            "thin release pack should demand release, decision, and anti-pattern capture",
        )?;
        ensure_equal(
            &missing,
            &templates,
            "each missing kind should have a capture template",
        )?;
        ensure(
            !report.nearest_insufficient.is_empty(),
            "thin pack should name nearest insufficient evidence",
        )
    }

    #[test]
    fn coverage_gap_clears_release_rule_after_capture() -> TestResult {
        let before = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            TokenBudget::new(200).map_err(|error| format!("budget rejected: {error:?}"))?,
            vec![candidate_with_content(
                1,
                0.95,
                0.5,
                20,
                "Run cargo fmt before editing code.",
            )?],
        )
        .map_err(|error| format!("before draft rejected: {error:?}"))?;
        let after = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            TokenBudget::new(200).map_err(|error| format!("budget rejected: {error:?}"))?,
            vec![
                candidate_with_content(1, 0.95, 0.5, 20, "Run cargo fmt before editing code.")?,
                candidate_with_content(
                    2,
                    0.94,
                    0.5,
                    20,
                    "Release rule: before release run verify, confirm rollback, then tag.",
                )?,
            ],
        )
        .map_err(|error| format!("after draft rejected: {error:?}"))?;

        let before_report = super::explain_coverage_gap("prepare release", &before);
        let after_report = super::explain_coverage_gap("prepare release", &after);

        ensure(
            before_report
                .missing_kinds
                .iter()
                .any(|gap| gap.kind == "release_rule"),
            "before capture should demand a release rule",
        )?;
        ensure(
            !after_report
                .missing_kinds
                .iter()
                .any(|gap| gap.kind == "release_rule"),
            "after capture should clear release rule demand",
        )?;
        ensure(
            after_report.missing_kinds.len() < before_report.missing_kinds.len(),
            "capture should reduce the missing-kind count",
        )?;
        ensure(
            !after_report
                .capture_templates
                .iter()
                .any(|template| template.kind == "release_rule"),
            "cleared demand should not keep a stale capture template",
        )
    }

    #[test]
    fn coverage_gap_report_is_deterministic_for_same_draft() -> TestResult {
        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            TokenBudget::new(200).map_err(|error| format!("budget rejected: {error:?}"))?,
            vec![
                candidate_with_content(1, 0.95, 0.5, 20, "Run cargo fmt before editing code.")?,
                candidate_with_content(2, 0.80, 0.5, 20, "Keep release notes concise.")?,
            ],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        let first = serde_json::to_value(super::explain_coverage_gap("prepare release", &draft))
            .map_err(|error| error.to_string())?;
        let second = serde_json::to_value(super::explain_coverage_gap("prepare release", &draft))
            .map_err(|error| error.to_string())?;
        ensure_equal(&first, &second, "coverage gap JSON must be stable")
    }

    #[test]
    fn why_not_freshness_penalty_treats_current_and_unknown_as_healthy() -> TestResult {
        for (status, window_kind) in [("current", "bounded"), ("unknown", "unbounded")] {
            let target =
                candidate_with_content(30, 0.8, 0.5, 10, format!("{status} lifecycle target"))?
                    .with_lifecycle(super::PackItemLifecycle {
                        validity_status: status.to_string(),
                        validity_window_kind: window_kind.to_string(),
                        valid_from: None,
                        valid_to: None,
                    });
            let penalty = super::why_not_freshness_penalty(&target);

            ensure_equal(&penalty.value, &0.0, "healthy lifecycle freshness penalty")?;
            ensure(
                !penalty
                    .signals
                    .iter()
                    .any(|signal| signal.starts_with("validity_status:")),
                format!("healthy status {status} should not emit validity_status penalty"),
            )?;
        }

        let expired = candidate_with_content(31, 0.8, 0.5, 10, "expired lifecycle target")?
            .with_lifecycle(super::PackItemLifecycle {
                validity_status: "expired".to_string(),
                validity_window_kind: "bounded".to_string(),
                valid_from: None,
                valid_to: None,
            });
        let penalty = super::why_not_freshness_penalty(&expired);

        ensure_equal(&penalty.value, &0.5, "expired freshness penalty")?;
        ensure(
            penalty
                .signals
                .iter()
                .any(|signal| signal == "validity_status:expired"),
            "expired lifecycle should emit validity_status penalty",
        )
    }

    #[test]
    fn facility_location_lazy_queue_matches_exhaustive_selector() -> TestResult {
        let budget =
            TokenBudget::new(1_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        let candidates = vec![
            candidate_with_content(1, 0.95, 0.6, 10, "cargo fmt release formatting")?
                .with_diversity_key("formatting"),
            candidate_with_content(2, 0.94, 0.6, 10, "cargo clippy release linting")?
                .with_diversity_key("linting"),
            candidate_with_content(3, 0.70, 0.9, 10, "signed checksum release artifact")?
                .with_diversity_key("artifact"),
            candidate_with_content(4, 0.69, 0.9, 10, "signed checksum package artifact")?
                .with_diversity_key("artifact"),
            candidate_with_content(5, 0.65, 0.7, 10, "rollback note incident failure")?
                .with_diversity_key("failure"),
            candidate_with_content(6, 0.60, 0.7, 10, "handoff context provenance evidence")?
                .with_diversity_key("evidence"),
        ];

        let expected = run_exhaustive_facility_selection(candidates.clone(), budget)?;
        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            candidates,
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let actual: Vec<MemoryId> = draft.items.iter().map(|item| item.memory_id).collect();

        ensure_equal(
            &actual,
            &expected,
            "lazy facility-location queue selection order",
        )
    }

    #[test]
    fn facility_location_lazy_queue_reduces_marginal_evaluations() -> TestResult {
        let candidate_count = 32_usize;
        let candidates = facility_benchmark_candidates(candidate_count)?;
        let budget =
            TokenBudget::new(10_000).map_err(|error| format!("budget rejected: {error:?}"))?;
        super::reset_facility_marginal_gain_evaluation_count();

        let draft = assemble_classic_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            candidates,
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.items.len(),
            &candidate_count,
            "all benchmark candidates fit",
        )?;
        let lazy_evaluations = super::facility_marginal_gain_evaluation_count();
        let exhaustive_evaluations = candidate_count
            .checked_mul(candidate_count.saturating_add(1))
            .and_then(|value| value.checked_div(2))
            .ok_or_else(|| "exhaustive evaluation count overflowed".to_owned())?;
        ensure(
            lazy_evaluations < exhaustive_evaluations / 2,
            format!(
                "lazy selector should avoid full rescans: lazy={lazy_evaluations}, exhaustive={exhaustive_evaluations}"
            ),
        )
    }

    #[test]
    #[ignore]
    fn facility_location_lazy_queue_benchmarks_against_exhaustive_selector() -> TestResult {
        let candidate_count = 128_usize;
        let candidates = facility_benchmark_candidates(candidate_count)?;
        let budget =
            TokenBudget::new(20_000).map_err(|error| format!("budget rejected: {error:?}"))?;

        super::reset_facility_marginal_gain_evaluation_count();
        let legacy_start = Instant::now();
        let expected = run_exhaustive_facility_selection(candidates.clone(), budget)?;
        let legacy_elapsed = legacy_start.elapsed();
        let legacy_evaluations = super::facility_marginal_gain_evaluation_count();

        super::reset_facility_marginal_gain_evaluation_count();
        let lazy_start = Instant::now();
        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            candidates,
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let lazy_elapsed = lazy_start.elapsed();
        let lazy_evaluations = super::facility_marginal_gain_evaluation_count();
        let actual: Vec<MemoryId> = draft.items.iter().map(|item| item.memory_id).collect();

        ensure_equal(&actual, &expected, "bench selection parity")?;
        eprintln!(
            "facility_location_lazy_queue_bench candidates={candidate_count} legacy_ms={:.3} lazy_ms={:.3} legacy_evaluations={legacy_evaluations} lazy_evaluations={lazy_evaluations}",
            legacy_elapsed.as_secs_f64() * 1_000.0,
            lazy_elapsed.as_secs_f64() * 1_000.0,
        );
        Ok(())
    }

    #[test]
    #[ignore]
    fn facility_section_usage_cache_benchmarks_against_item_scan() -> TestResult {
        let item_count = 256_u32;
        let iterations = 100_000_u32;
        let section = PackSection::ProceduralRules;
        let mut items = Vec::new();
        let mut section_usage = super::SectionTokenUsage::default();

        for offset in 0..item_count {
            let candidate = candidate_in_section(
                u128::from(offset).saturating_add(1),
                section,
                0.9,
                0.5,
                10,
                format!("cached section usage benchmark item {offset}"),
            )?;
            section_usage.add_candidate(&candidate);
            items.push(super::PackDraftItem::from_selected_candidate(
                offset.saturating_add(1),
                candidate,
                Vec::new(),
                PackSelectionPhase::StrictMmr,
            ));
        }

        let legacy_start = Instant::now();
        let mut legacy_total = 0_u64;
        for _ in 0..iterations {
            let section_used: u32 = items
                .iter()
                .filter(|item| item.section == section)
                .map(|item| item.estimated_tokens)
                .sum();
            legacy_total = legacy_total.saturating_add(u64::from(section_used));
        }
        let legacy_elapsed = legacy_start.elapsed();

        let cached_start = Instant::now();
        let mut cached_total = 0_u64;
        for _ in 0..iterations {
            cached_total =
                cached_total.saturating_add(u64::from(section_usage.tokens_for(section)));
        }
        let cached_elapsed = cached_start.elapsed();

        ensure_equal(
            &cached_total,
            &legacy_total,
            "cached section usage must match legacy item scan",
        )?;
        eprintln!(
            "facility_section_usage_cache_bench items={item_count} iterations={iterations} legacy_ms={:.3} cached_ms={:.3}",
            legacy_elapsed.as_secs_f64() * 1_000.0,
            cached_elapsed.as_secs_f64() * 1_000.0,
        );
        Ok(())
    }

    #[test]
    fn submodular_profile_emits_facility_location_certificate() -> TestResult {
        let budget =
            TokenBudget::new(150).map_err(|error| format!("budget rejected: {error:?}"))?;
        let first =
            candidate_with_content(1, 1.0, 0.6, 10, "Run cargo fmt --check before release.")?
                .with_diversity_key("release-formatting");
        let near_duplicate = candidate_with_content(
            2,
            0.95,
            0.6,
            10,
            "Always run cargo fmt --check before release.",
        )?
        .with_diversity_key("release-formatting");
        let diverse = candidate_with_content(
            3,
            0.65,
            0.8,
            10,
            "Verify signed release assets and checksums after packaging.",
        )?
        .with_diversity_key("release-artifacts");

        let draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "prepare release",
            budget,
            vec![near_duplicate, diverse, first],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(
            &draft.selection_audit.profile,
            &ContextPackProfile::Submodular,
            "certificate profile",
        )?;
        ensure_equal(
            &draft.selection_audit.objective,
            &PackSelectionObjective::FacilityLocation,
            "certificate objective",
        )?;
        ensure(
            draft.selection_audit.monotone,
            "facility-location certificate should mark monotone",
        )?;
        ensure(
            draft.selection_audit.submodular,
            "facility-location certificate should mark submodular",
        )?;
        ensure_equal(
            &draft.selection_audit.candidate_count,
            &3,
            "candidate count",
        )?;
        ensure_equal(
            &draft.selection_audit.steps.len(),
            &3,
            "all candidates fitting overall and section budgets receive certificate steps",
        )?;
        ensure(
            draft.selection_audit.total_objective_value > 0.0,
            "objective value should be positive",
        )?;
        ensure(
            draft.selection_audit.steps.iter().any(|step| {
                step.covered_features
                    .iter()
                    .any(|feature| feature == "diversity:release-artifacts")
            }),
            "certificate should name the diverse feature",
        )
    }

    #[test]
    fn assemble_draft_routes_exact_normalized_duplicate_to_coverage_fill() -> TestResult {
        let budget = match TokenBudget::new(100) {
            Ok(budget) => budget,
            Err(error) => return Err(format!("budget rejected: {error:?}")),
        };
        let first =
            candidate_with_content(1, 0.9, 0.5, 10, "Run cargo fmt --check before release.")?;
        let duplicate = candidate_with_content(
            2,
            0.8,
            0.5,
            10,
            "  Run   cargo fmt --check before release.  ",
        )?;

        let draft = assemble_draft("prepare release", budget, vec![duplicate, first])
            .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(&draft.items.len(), &2, "duplicate selected in fill pass")?;
        ensure_equal(
            &draft.items.first().map(|item| item.memory_id),
            &Some(memory_id(1)),
            "highest relevance duplicate selected",
        )?;
        ensure_equal(
            &draft.items.get(1).map(|item| item.memory_id),
            &Some(memory_id(2)),
            "lower relevance duplicate selected by coverage fill",
        )?;
        ensure_equal(
            &draft.items.get(1).map(|item| item.selected_in),
            &Some(PackSelectionPhase::CoverageFill),
            "duplicate selection phase",
        )?;
        ensure_equal(
            &draft.omitted.len(),
            &0,
            "no exact duplicate omitted when fill can use budget",
        )
    }

    #[test]
    fn assemble_draft_never_selects_same_memory_id_twice() -> TestResult {
        let budget =
            TokenBudget::new(100).map_err(|error| format!("budget rejected: {error:?}"))?;
        let first =
            candidate_with_content(1, 0.9, 0.5, 10, "Run cargo fmt --check before release.")?;
        let duplicate_same_memory = candidate_with_content(
            1,
            0.8,
            0.5,
            10,
            "Run cargo clippy --all-targets before release.",
        )?;

        let draft = assemble_draft(
            "prepare release",
            budget,
            vec![duplicate_same_memory, first],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;

        ensure_equal(&draft.items.len(), &1, "same memory selected once")?;
        ensure_equal(
            &draft.items.first().map(|item| item.memory_id),
            &Some(memory_id(1)),
            "selected memory id",
        )?;
        ensure_equal(&draft.omitted.len(), &1, "duplicate memory omitted")?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.memory_id),
            &Some(memory_id(1)),
            "omitted duplicate memory id",
        )?;
        ensure_equal(
            &draft.omitted.first().map(|omission| omission.reason),
            &Some(PackOmissionReason::RedundantCandidate),
            "duplicate memory omission reason",
        )
    }

    #[test]
    fn context_response_wraps_request_pack_and_degradation_contract() -> TestResult {
        let request = ContextRequest::from_query("format before release")
            .map_err(|error| format!("request rejected: {error:?}"))?;
        let draft = assemble_draft(
            request.query.clone(),
            request.budget,
            vec![candidate(1, 1.0, 0.5, 10)?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let degraded = ContextResponseDegradation::new(
            "semantic_index_unavailable",
            ContextResponseSeverity::Medium,
            "Semantic search is unavailable; lexical retrieval was used.",
            Some("ee index rebuild --workspace .".to_string()),
        )
        .map_err(|error| format!("degradation rejected: {error:?}"))?;

        let response = ContextResponse::new(request, draft, vec![degraded])
            .map_err(|error| format!("response rejected: {error:?}"))?;

        ensure_equal(&response.schema, &"ee.response.v2", "response schema")?;
        ensure(response.success, "context response success flag")?;
        ensure_equal(
            &response.data.command,
            &PACK_COMMAND,
            "pack response command",
        )?;
        ensure_equal(
            &response.data.pack.items.len(),
            &1,
            "context response pack item count",
        )?;
        ensure_equal(
            &response
                .data
                .degraded
                .first()
                .map(|degraded| degraded.severity.as_str()),
            &Some("medium"),
            "degradation severity wire name",
        )?;
        ensure_equal(
            &response
                .data
                .degraded
                .first()
                .and_then(|degraded| degraded.repair.as_deref()),
            &Some("ee index rebuild --workspace ."),
            "degradation repair",
        )
    }

    #[test]
    fn context_response_degradation_preserves_critical_severity() -> TestResult {
        let degraded = ContextResponseDegradation::new(
            "mesh_cursor_repair_required",
            ContextResponseSeverity::Critical,
            "Mesh cursor repair is required before continuing.",
            Some("ee mesh repair-cursor --json".to_string()),
        )
        .map_err(|error| format!("degradation rejected: {error:?}"))?;

        ensure_equal(
            &degraded.severity.as_str(),
            &"critical",
            "critical severity wire name",
        )
    }

    #[test]
    fn revisable_pack_metadata_is_explicit_and_deterministic() -> TestResult {
        let request = ContextRequest::from_query("format before release")
            .map_err(|error| format!("request rejected: {error:?}"))?;
        let draft = assemble_draft(
            request.query.clone(),
            request.budget,
            vec![candidate(1, 1.0, 0.5, 10)?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let response = ContextResponse::new(request, draft, Vec::new())
            .map_err(|error| format!("response rejected: {error:?}"))?;

        ensure(
            PackRevisionMeshMetadata::for_context_response(
                &response,
                MeshCommandMode::Off,
                "context",
            )
            .is_none(),
            "strict/off mode must not emit revision metadata",
        )?;
        let first = PackRevisionMeshMetadata::for_context_response(
            &response,
            MeshCommandMode::Revisable,
            "context",
        )
        .ok_or_else(|| "revisable mode should emit revision metadata".to_owned())?;
        let replay = PackRevisionMeshMetadata::for_context_response(
            &response,
            MeshCommandMode::Revisable,
            "context",
        )
        .ok_or_else(|| "revisable replay should emit revision metadata".to_owned())?;

        ensure_equal(&first, &replay, "revision metadata replay")?;
        ensure_equal(
            &first.schema,
            &PACK_REVISION_TOKEN_SCHEMA_V1,
            "revision schema",
        )?;
        ensure(first.token.starts_with("packrev_"), "revision token prefix")?;
        ensure(first.tier1_usable, "tier1 pack remains usable")?;
        ensure(
            !first.revision_available,
            "no peer freshness is silently claimed",
        )?;
        ensure(
            first.query_hash.starts_with("blake3:"),
            "query fingerprint prefix",
        )?;
        ensure_equal(
            &first.local_mesh_tip_state.status,
            &"not_checked",
            "local mesh tip state",
        )?;
        ensure_equal(
            &first.selected_memory_ids,
            &vec![memory_id(1).to_string()],
            "selected memory ids",
        )?;

        let other_request = ContextRequest::from_query("prepare release")
            .map_err(|error| format!("other request rejected: {error:?}"))?;
        let other_draft = assemble_draft(
            other_request.query.clone(),
            other_request.budget,
            vec![candidate(1, 1.0, 0.5, 10)?],
        )
        .map_err(|error| format!("other draft rejected: {error:?}"))?;
        let other_response = ContextResponse::new(other_request, other_draft, Vec::new())
            .map_err(|error| format!("other response rejected: {error:?}"))?;
        let other = PackRevisionMeshMetadata::for_context_response(
            &other_response,
            MeshCommandMode::Revisable,
            "context",
        )
        .ok_or_else(|| "other revisable response should emit revision metadata".to_owned())?;
        ensure(
            first.token != other.token,
            "query fingerprint must influence revision token",
        )
    }

    fn slo_actuals(
        scanned_count: usize,
        graph_edges_traversed: usize,
        elapsed_ms: u64,
    ) -> PackAssemblySloActuals {
        PackAssemblySloActuals {
            candidate_count: scanned_count,
            scanned_count,
            index_generation: Some(12),
            graph_generation: Some(12),
            graph_edges_traversed,
            elapsed_ms,
            memory_bytes_peak: 4096,
        }
    }

    #[test]
    fn pack_resource_profile_parse_normalizes_cli_values() -> TestResult {
        ensure_equal(
            &" lean "
                .parse::<PackResourceProfile>()
                .map_err(|error| error.to_string())?,
            &PackResourceProfile::Lean,
            "lean profile",
        )?;
        ensure_equal(
            &"SWARM-HEAVY"
                .parse::<PackResourceProfile>()
                .map_err(|error| error.to_string())?,
            &PackResourceProfile::SwarmHeavy,
            "swarm-heavy profile",
        )?;
        ensure_equal(
            &"swarmHeavy"
                .parse::<PackResourceProfile>()
                .map_err(|error| error.to_string())?,
            &PackResourceProfile::SwarmHeavy,
            "camelCase swarm-heavy profile",
        )?;
        ensure_equal(
            &"SwarmHeavy"
                .parse::<PackResourceProfile>()
                .map_err(|error| error.to_string())?,
            &PackResourceProfile::SwarmHeavy,
            "PascalCase swarm-heavy profile",
        )
    }

    #[test]
    fn pack_assembly_slo_classifies_within_warning_and_failure() -> TestResult {
        let within =
            PackAssemblySlo::evaluate(PackResourceProfile::Standard, slo_actuals(12, 100, 25));
        ensure_equal(
            &within.status,
            &PackAssemblySloStatus::WithinBudget,
            "within-budget SLO status",
        )?;
        ensure_equal(&within.degradations.len(), &0, "within-budget degradations")?;
        ensure_equal(
            &within.budget_class.candidates_scanned_max,
            &240,
            "standard candidate cap",
        )?;

        let warning =
            PackAssemblySlo::evaluate(PackResourceProfile::Lean, slo_actuals(80, 100, 25));
        ensure_equal(
            &warning.status,
            &PackAssemblySloStatus::Warning,
            "lean cap boundary is warning",
        )?;
        ensure_equal(
            &warning.degradations.first().map(|entry| entry.code),
            &Some(PACK_ASSEMBLY_SLOW_CODE),
            "warning degradation code",
        )?;

        let failure =
            PackAssemblySlo::evaluate(PackResourceProfile::Lean, slo_actuals(81, 100, 25));
        ensure_equal(
            &failure.status,
            &PackAssemblySloStatus::Failure,
            "over-cap SLO status",
        )?;
        ensure_equal(
            &failure.degradations.first().map(|entry| entry.code),
            &Some(PACK_ASSEMBLY_BUDGET_EXCEEDED_CODE),
            "failure degradation code",
        )
    }

    #[test]
    fn peer_human_attested_is_authoritative_and_ranked_between_local_human_and_agent() -> TestResult
    {
        ensure_equal(
            &PackTrustPosture::for_class(TrustClass::PeerHumanAttested),
            &PackTrustPosture::Authoritative,
            "peer human pack posture",
        )?;
        ensure(
            trust_class_rank_milli(TrustClass::HumanExplicit)
                > trust_class_rank_milli(TrustClass::PeerHumanAttested),
            "local human trust must outrank peer attestation",
        )?;
        ensure(
            trust_class_rank_milli(TrustClass::PeerHumanAttested)
                > trust_class_rank_milli(TrustClass::AgentValidated),
            "peer attestation must outrank agent validation",
        )
    }

    #[test]
    fn advisory_banner_separates_trust_postures_and_degradations() -> TestResult {
        let request = ContextRequest::from_query("review imported release rule")
            .map_err(|error| format!("request rejected: {error:?}"))?;
        let human = candidate(1, 0.9, 0.8, 10)?.with_trust_signal(PackTrustSignal::new(
            TrustClass::HumanExplicit,
            Some("project-rule".to_string()),
        ));
        let peer_human = candidate(4, 0.85, 0.75, 10)?.with_trust_signal(PackTrustSignal::new(
            TrustClass::PeerHumanAttested,
            Some("team-rule".to_string()),
        ));
        let agent = candidate(2, 0.8, 0.7, 10)?
            .with_trust_signal(PackTrustSignal::new(TrustClass::AgentAssertion, None));
        let legacy = candidate(3, 0.7, 0.6, 10)?
            .with_trust_signal(PackTrustSignal::new(TrustClass::LegacyImport, None));
        let draft = assemble_draft(
            request.query.clone(),
            request.budget,
            vec![human, peer_human, agent, legacy],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let degraded = ContextResponseDegradation::new(
            "semantic_index_unavailable",
            ContextResponseSeverity::Medium,
            "Semantic search is unavailable; lexical retrieval was used.",
            Some("ee index rebuild --workspace .".to_string()),
        )
        .map_err(|error| format!("degradation rejected: {error:?}"))?;
        let response = ContextResponse::new(request, draft, vec![degraded])
            .map_err(|error| format!("response rejected: {error:?}"))?;

        let banner = response.data.advisory_banner();
        ensure_equal(&banner.status.as_str(), &"degraded", "banner status")?;
        ensure_equal(&banner.authoritative_count, &2, "authoritative count")?;
        ensure_equal(&banner.advisory_count, &1, "advisory count")?;
        ensure_equal(&banner.legacy_count, &1, "legacy count")?;
        ensure_equal(&banner.degradation_count, &1, "degradation count")?;
        // Bead bd-17c65.5.2 (E2): the meta-`degraded_context` summary
        // note is gone; the trust-posture notes remain (`advisory_memory`
        // and `legacy_memory`). Per-signal information continues to
        // surface in `data.degraded[]` (verified via degradation_count
        // above) — the meta-summary was redundant prose.
        ensure_equal(&banner.notes.len(), &2, "note count")?;
        ensure_equal(&banner.notes[0].code, &"advisory_memory", "first note code")?;
        ensure_equal(&banner.notes[1].code, &"legacy_memory", "second note code")?;
        ensure_equal(
            &banner.notes[0].memory_ids,
            &vec![memory_id(2).to_string()],
            "advisory memory ids",
        )?;
        ensure_equal(
            &banner.notes[1].memory_ids,
            &vec![memory_id(3).to_string()],
            "legacy memory ids",
        )
    }

    #[test]
    fn advisory_banner_names_lexical_only_when_embed_model_is_unavailable() -> TestResult {
        let request = ContextRequest::from_query("prepare safe release")
            .map_err(|error| format!("request rejected: {error:?}"))?;
        let draft = assemble_draft(
            request.query.clone(),
            request.budget,
            vec![candidate(1, 0.9, 0.8, 10)?],
        )
        .map_err(|error| format!("draft rejected: {error:?}"))?;
        let degraded = ContextResponseDegradation::new(
            "embed_model_unavailable",
            ContextResponseSeverity::Warning,
            "Embedding model unavailable; semantic similarity is disabled.",
            Some("ee index reembed --workspace .".to_string()),
        )
        .map_err(|error| format!("degradation rejected: {error:?}"))?;
        let response = ContextResponse::new(request, draft, vec![degraded])
            .map_err(|error| format!("response rejected: {error:?}"))?;

        let banner = response.data.advisory_banner();
        ensure_equal(&banner.status.as_str(), &"degraded", "banner status")?;
        ensure(
            banner.summary.contains("semantic embedding is unavailable"),
            "banner should name unavailable semantic embedding",
        )?;
        ensure(
            banner.summary.contains("lexical-only"),
            "banner should tell agents to treat ranking as lexical-only",
        )
    }

    #[test]
    fn context_response_rejects_mismatched_query_and_invalid_degradation() -> TestResult {
        let request = ContextRequest::from_query("prepare release")
            .map_err(|error| format!("request rejected: {error:?}"))?;
        let draft = assemble_draft("different task", request.budget, Vec::new())
            .map_err(|error| format!("draft rejected: {error:?}"))?;
        let response = ContextResponse::new(request, draft, Vec::new());
        ensure(
            matches!(
                response,
                Err(PackValidationError::ContextResponseQueryMismatch { .. })
            ),
            "mismatched response query must be rejected",
        )?;

        let empty_code = ContextResponseDegradation::new(
            " ",
            ContextResponseSeverity::Low,
            "fallback used",
            None,
        );
        ensure(
            matches!(empty_code, Err(PackValidationError::EmptyDegradationCode)),
            "empty degradation code must be rejected",
        )?;

        let empty_message = ContextResponseDegradation::new(
            "fallback_used",
            ContextResponseSeverity::High,
            " ",
            None,
        );
        ensure(
            matches!(
                empty_message,
                Err(PackValidationError::EmptyDegradationMessage { .. })
            ),
            "empty degradation message must be rejected",
        )
    }

    #[test]
    fn assemble_draft_rejects_empty_query() -> TestResult {
        let budget = match TokenBudget::new(10) {
            Ok(budget) => budget,
            Err(error) => return Err(format!("budget rejected: {error:?}")),
        };
        let draft = assemble_draft(" ", budget, vec![candidate(1, 0.5, 0.5, 5)?]);
        ensure(
            matches!(draft, Err(PackValidationError::EmptyQuery)),
            "empty query must be rejected",
        )
    }

    // ========================================================================
    // EE-344: Sampled submodularity, monotonicity, and tiny-fixture audits
    // ========================================================================

    fn test_facility_value(selected_seeds: &[u128], candidates: &[PackCandidate]) -> f32 {
        use super::{CandidateSignature, facility_location_value};
        let signatures: Vec<CandidateSignature> = selected_seeds
            .iter()
            .filter_map(|&seed| {
                candidates
                    .iter()
                    .find(|c| c.memory_id == memory_id(seed))
                    .map(CandidateSignature::from)
            })
            .collect();
        facility_location_value(&signatures, candidates)
    }

    #[test]
    fn facility_location_monotonicity_adding_element_never_decreases_value() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.9, 0.7, 10, "Alpha formatting rule")?,
            candidate_with_content(2, 0.85, 0.6, 10, "Beta linting rule")?,
            candidate_with_content(3, 0.75, 0.8, 10, "Gamma testing rule")?,
            candidate_with_content(4, 0.65, 0.5, 10, "Delta deployment rule")?,
        ];

        let f_empty = test_facility_value(&[], &candidates);
        let f_1 = test_facility_value(&[1], &candidates);
        let f_12 = test_facility_value(&[1, 2], &candidates);
        let f_123 = test_facility_value(&[1, 2, 3], &candidates);
        let f_1234 = test_facility_value(&[1, 2, 3, 4], &candidates);

        ensure(f_empty <= f_1, "f(∅) ≤ f({1})")?;
        ensure(f_1 <= f_12, "f({1}) ≤ f({1,2})")?;
        ensure(f_12 <= f_123, "f({1,2}) ≤ f({1,2,3})")?;
        ensure(f_123 <= f_1234, "f({1,2,3}) ≤ f({1,2,3,4})")?;

        let f_2 = test_facility_value(&[2], &candidates);
        let f_23 = test_facility_value(&[2, 3], &candidates);
        ensure(f_2 <= f_23, "f({2}) ≤ f({2,3})")?;

        let f_3 = test_facility_value(&[3], &candidates);
        let f_34 = test_facility_value(&[3, 4], &candidates);
        ensure(f_3 <= f_34, "f({3}) ≤ f({3,4})")?;

        Ok(())
    }

    #[test]
    fn facility_location_submodularity_diminishing_marginal_returns() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.9, 0.7, 10, "Alpha formatting rule")?,
            candidate_with_content(2, 0.85, 0.6, 10, "Beta linting rule")?,
            candidate_with_content(3, 0.75, 0.8, 10, "Gamma testing rule")?,
            candidate_with_content(4, 0.65, 0.5, 10, "Delta deployment rule")?,
        ];

        let f_1 = test_facility_value(&[1], &candidates);
        let f_empty = test_facility_value(&[], &candidates);
        let f_12 = test_facility_value(&[1, 2], &candidates);
        let f_2 = test_facility_value(&[2], &candidates);

        let marginal_add_1_to_empty = f_1 - f_empty;
        let marginal_add_1_to_2 = f_12 - f_2;
        ensure(
            marginal_add_1_to_2 <= marginal_add_1_to_empty + 0.000_001,
            format!(
                "submodularity: f({{1}}) - f(∅) ≥ f({{1,2}}) - f({{2}}): {} ≥ {}",
                marginal_add_1_to_empty, marginal_add_1_to_2
            ),
        )?;

        let f_123 = test_facility_value(&[1, 2, 3], &candidates);
        let f_23 = test_facility_value(&[2, 3], &candidates);
        let marginal_add_1_to_23 = f_123 - f_23;
        ensure(
            marginal_add_1_to_23 <= marginal_add_1_to_empty + 0.000_001,
            format!(
                "submodularity: f({{1}}) - f(∅) ≥ f({{1,2,3}}) - f({{2,3}}): {} ≥ {}",
                marginal_add_1_to_empty, marginal_add_1_to_23
            ),
        )?;

        let f_3 = test_facility_value(&[3], &candidates);
        let marginal_add_3_to_empty = f_3 - f_empty;
        let marginal_add_3_to_12 = f_123 - f_12;
        ensure(
            marginal_add_3_to_12 <= marginal_add_3_to_empty + 0.000_001,
            format!(
                "submodularity: f({{3}}) - f(∅) ≥ f({{1,2,3}}) - f({{1,2}}): {} ≥ {}",
                marginal_add_3_to_empty, marginal_add_3_to_12
            ),
        )?;

        Ok(())
    }

    #[test]
    fn facility_location_submodularity_union_intersection_inequality() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.9, 0.7, 10, "Alpha formatting rule")?,
            candidate_with_content(2, 0.85, 0.6, 10, "Beta linting rule")?,
            candidate_with_content(3, 0.75, 0.8, 10, "Gamma testing rule")?,
            candidate_with_content(4, 0.65, 0.5, 10, "Delta deployment rule")?,
        ];

        let a = [1_u128, 2];
        let b = [2_u128, 3];
        let union = [1_u128, 2, 3];
        let intersection = [2_u128];

        let f_a = test_facility_value(&a, &candidates);
        let f_b = test_facility_value(&b, &candidates);
        let f_union = test_facility_value(&union, &candidates);
        let f_intersection = test_facility_value(&intersection, &candidates);

        ensure(
            f_union + f_intersection <= f_a + f_b + 0.000_001,
            format!(
                "submodularity: f(A ∪ B) + f(A ∩ B) ≤ f(A) + f(B): {} + {} ≤ {} + {}",
                f_union, f_intersection, f_a, f_b
            ),
        )?;

        let a2 = [1_u128, 3];
        let b2 = [2_u128, 4];
        let union2 = [1_u128, 2, 3, 4];
        let intersection2: [u128; 0] = [];

        let f_a2 = test_facility_value(&a2, &candidates);
        let f_b2 = test_facility_value(&b2, &candidates);
        let f_union2 = test_facility_value(&union2, &candidates);
        let f_intersection2 = test_facility_value(&intersection2, &candidates);

        ensure(
            f_union2 + f_intersection2 <= f_a2 + f_b2 + 0.000_001,
            format!(
                "submodularity (disjoint): f(A ∪ B) + f(∅) ≤ f(A) + f(B): {} + {} ≤ {} + {}",
                f_union2, f_intersection2, f_a2, f_b2
            ),
        )?;

        Ok(())
    }

    #[test]
    fn tiny_fixture_greedy_matches_brute_force_for_uniform_budget() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.9, 0.6, 10, "Alpha rule one")?,
            candidate_with_content(2, 0.7, 0.5, 10, "Beta rule two")?,
            candidate_with_content(3, 0.5, 0.4, 10, "Gamma rule three")?,
        ];

        // Use 200-token budget so section quotas (20% each for procedural_rules)
        // have enough room for 10-token candidates
        let budget = TokenBudget::new(200).map_err(|e| format!("budget: {e:?}"))?;
        let greedy_draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "tiny fixture",
            budget,
            candidates.clone(),
        )
        .map_err(|e| format!("greedy draft: {e:?}"))?;

        let greedy_value = greedy_draft.selection_audit.total_objective_value;
        let greedy_count = greedy_draft.items.len();

        // Brute force: find best subset that fits in section quota (40 tokens for procedural_rules)
        let mut best_brute_force = 0.0_f32;
        let mut best_count = 0_usize;

        for mask in 0_u8..8_u8 {
            let mut selected: Vec<u128> = Vec::new();
            let mut total_tokens = 0_u32;
            for bit in 0..3 {
                if (mask >> bit) & 1 == 1 {
                    selected.push((bit + 1) as u128);
                    total_tokens += 10;
                }
            }
            // Section quota is 40 tokens (200 * 0.20) for procedural_rules
            if total_tokens <= 40 {
                let value = test_facility_value(&selected, &candidates);
                if value > best_brute_force {
                    best_brute_force = value;
                    best_count = selected.len();
                }
            }
        }

        ensure(
            greedy_value >= best_brute_force * 0.63 - 0.000_001,
            format!(
                "greedy (count={}, value={}) should be ≥63% of brute-force (count={}, value={})",
                greedy_count, greedy_value, best_count, best_brute_force
            ),
        )?;

        // Greedy should achieve the optimum for this tiny fixture
        ensure(
            (greedy_value - best_brute_force).abs() < 0.000_001,
            format!(
                "tiny fixture: greedy ({}) should match brute-force optimum ({})",
                greedy_value, best_brute_force
            ),
        )?;

        Ok(())
    }

    #[test]
    fn tiny_fixture_greedy_handles_non_uniform_token_costs() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.9, 0.6, 5, "Small alpha")?,
            candidate_with_content(2, 0.8, 0.7, 15, "Large beta")?,
            candidate_with_content(3, 0.6, 0.5, 8, "Medium gamma")?,
        ];

        // 150-token budget gives 30 tokens to procedural_rules section (20%)
        // This allows combinations like [5], [15], [8], [5+8=13], etc.
        let budget = TokenBudget::new(150).map_err(|e| format!("budget: {e:?}"))?;
        let section_quota = 30_u32; // 150 * 0.20 = 30 tokens for procedural_rules

        let greedy_draft = assemble_draft_with_profile(
            ContextPackProfile::Submodular,
            "non-uniform tokens",
            budget,
            candidates.clone(),
        )
        .map_err(|e| format!("greedy draft: {e:?}"))?;

        let greedy_value = greedy_draft.selection_audit.total_objective_value;
        let greedy_used = greedy_draft.used_tokens;

        ensure(
            greedy_used <= section_quota,
            format!(
                "greedy should respect section quota: {} ≤ {}",
                greedy_used, section_quota
            ),
        )?;

        let mut best_brute_force = 0.0_f32;
        let token_costs = [5_u32, 15, 8];

        for mask in 0_u8..8_u8 {
            let mut selected: Vec<u128> = Vec::new();
            let mut total_tokens = 0_u32;
            for (bit, token_cost) in token_costs.iter().copied().enumerate() {
                if (mask >> bit) & 1 == 1 {
                    selected.push((bit + 1) as u128);
                    total_tokens += token_cost;
                }
            }
            // Brute force also respects section quota
            if total_tokens <= section_quota {
                let value = test_facility_value(&selected, &candidates);
                if value > best_brute_force {
                    best_brute_force = value;
                }
            }
        }

        ensure(
            greedy_value >= best_brute_force * 0.63 - 0.000_001,
            format!(
                "greedy ({}) should achieve at least 63% of brute-force optimum ({})",
                greedy_value, best_brute_force
            ),
        )?;

        Ok(())
    }

    #[test]
    fn sampled_random_subsets_satisfy_monotonicity() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.95, 0.8, 10, "Rule one about formatting")?,
            candidate_with_content(2, 0.90, 0.7, 10, "Rule two about linting")?,
            candidate_with_content(3, 0.80, 0.6, 10, "Rule three about testing")?,
            candidate_with_content(4, 0.70, 0.5, 10, "Rule four about docs")?,
            candidate_with_content(5, 0.60, 0.4, 10, "Rule five about CI")?,
        ];

        let test_cases: &[(&[u128], &[u128])] = &[
            (&[], &[1]),
            (&[1], &[1, 2]),
            (&[2], &[1, 2]),
            (&[1, 3], &[1, 2, 3]),
            (&[2, 4], &[1, 2, 4]),
            (&[1, 2, 3], &[1, 2, 3, 4]),
            (&[1, 3, 5], &[1, 2, 3, 5]),
            (&[], &[1, 2, 3, 4, 5]),
        ];

        for (subset, superset) in test_cases {
            let f_subset = test_facility_value(subset, &candidates);
            let f_superset = test_facility_value(superset, &candidates);
            ensure(
                f_subset <= f_superset + 0.000_001,
                format!(
                    "monotonicity: f({:?}) ≤ f({:?}): {} ≤ {}",
                    subset, superset, f_subset, f_superset
                ),
            )?;
        }

        Ok(())
    }

    #[test]
    fn sampled_submodularity_across_diverse_content() -> TestResult {
        let candidates = vec![
            candidate_with_content(1, 0.9, 0.7, 10, "Run cargo fmt before commits")?
                .with_diversity_key("formatting"),
            candidate_with_content(2, 0.85, 0.6, 10, "Run cargo clippy for lints")?
                .with_diversity_key("linting"),
            candidate_with_content(3, 0.8, 0.8, 10, "Run cargo test before push")?
                .with_diversity_key("testing"),
            candidate_with_content(4, 0.75, 0.5, 10, "Use git pull --rebase")?
                .with_diversity_key("git"),
            candidate_with_content(5, 0.7, 0.6, 10, "Keep PR scope small")?
                .with_diversity_key("process"),
        ];

        let pairs: &[(&[u128], &[u128], u128)] = &[
            (&[], &[1], 2),
            (&[1], &[1, 3], 2),
            (&[2], &[1, 2, 3], 4),
            (&[1, 2], &[1, 2, 3, 4], 5),
        ];

        for (smaller, larger, element) in pairs {
            let f_smaller = test_facility_value(smaller, &candidates);
            let f_larger = test_facility_value(larger, &candidates);

            let mut with_element_small: Vec<u128> = smaller.to_vec();
            if !with_element_small.contains(element) {
                with_element_small.push(*element);
            }
            let f_smaller_plus = test_facility_value(&with_element_small, &candidates);

            let mut with_element_large: Vec<u128> = larger.to_vec();
            if !with_element_large.contains(element) {
                with_element_large.push(*element);
            }
            let f_larger_plus = test_facility_value(&with_element_large, &candidates);

            let marginal_small = f_smaller_plus - f_smaller;
            let marginal_large = f_larger_plus - f_larger;

            ensure(
                marginal_large <= marginal_small + 0.000_001,
                format!(
                    "submodularity: adding {} to {:?} gives {} gain, to {:?} gives {} gain (should be ≤)",
                    element, smaller, marginal_small, larger, marginal_large
                ),
            )?;
        }

        Ok(())
    }

    // ========================================================================
    // Rate-Distortion Tests (EE-345)
    // ========================================================================

    use super::{
        RATE_DISTORTION_SCHEMA_V1, RateDistortionReport, SectionBudgetReport,
        compute_rate_distortion,
    };

    #[test]
    fn rate_distortion_report_computes_rate() -> TestResult {
        let report = RateDistortionReport::new(4000, 3200);
        ensure(
            (report.rate - 0.8).abs() < 0.0001,
            format!("expected rate 0.8, got {}", report.rate),
        )
    }

    #[test]
    fn rate_distortion_report_computes_slack() -> TestResult {
        let report = RateDistortionReport::new(4000, 3200);
        ensure(
            report.slack() == 800,
            format!("expected slack 800, got {}", report.slack()),
        )
    }

    #[test]
    fn rate_distortion_report_computes_utilization() -> TestResult {
        let report = RateDistortionReport::new(4000, 3200);
        ensure(
            (report.utilization_percent() - 80.0).abs() < 0.01,
            format!(
                "expected utilization 80%, got {}%",
                report.utilization_percent()
            ),
        )
    }

    #[test]
    fn rate_distortion_report_with_candidates() -> TestResult {
        let report = RateDistortionReport::new(4000, 3200).with_candidates(10, 5);
        ensure(
            report.included_candidates == 10,
            format!("expected 10 included, got {}", report.included_candidates),
        )?;
        ensure(
            report.omitted_candidates == 5,
            format!("expected 5 omitted, got {}", report.omitted_candidates),
        )?;
        ensure(
            (report.quality_score - 0.6667).abs() < 0.001,
            format!("expected quality ~0.667, got {}", report.quality_score),
        )?;
        ensure(
            (report.distortion - 0.3333).abs() < 0.001,
            format!("expected distortion ~0.333, got {}", report.distortion),
        )
    }

    #[test]
    fn rate_distortion_candidate_count_arithmetic_is_total() -> TestResult {
        let report = RateDistortionReport::new(1, 1).with_candidates(u32::MAX, 1);
        ensure(
            report.included_candidates == u32::MAX,
            format!(
                "expected u32::MAX included, got {}",
                report.included_candidates
            ),
        )?;
        ensure(
            report.omitted_candidates == 1,
            format!(
                "expected one omitted candidate, got {}",
                report.omitted_candidates
            ),
        )?;
        ensure(
            report.quality_score.is_finite() && report.distortion.is_finite(),
            "candidate ratios must remain finite for arbitrary u32 counts",
        )?;
        ensure(
            (report.quality_score + report.distortion - 1.0).abs() < f64::EPSILON,
            format!(
                "quality + distortion should equal 1.0, got {} + {}",
                report.quality_score, report.distortion
            ),
        )
    }

    #[test]
    fn rate_distortion_report_to_json() -> TestResult {
        let mut report = RateDistortionReport::new(4000, 3200).with_candidates(10, 5);
        report.add_section(SectionBudgetReport::new("procedural", 1200, 1000).with_candidates(4));
        let json = report.to_json();

        ensure_contains(&json, RATE_DISTORTION_SCHEMA_V1, "schema")?;
        ensure_contains(&json, "\"budgetTokens\":4000", "budget")?;
        ensure_contains(&json, "\"usedTokens\":3200", "used")?;
        ensure_contains(&json, "\"slackTokens\":800", "slack")?;
        ensure_contains(&json, "\"rate\":0.8", "rate")?;
        ensure_contains(&json, "\"includedCandidates\":10", "included")?;
        ensure_contains(&json, "\"omittedCandidates\":5", "omitted")?;
        ensure_contains(&json, "\"sections\":[", "sections array")
    }

    #[test]
    fn rate_distortion_report_to_human() -> TestResult {
        let report = RateDistortionReport::new(4000, 3200).with_candidates(10, 5);
        let human = report.to_human();

        ensure_contains(&human, "Rate-Distortion Budget Report", "title")?;
        ensure_contains(&human, "Budget:", "budget label")?;
        ensure_contains(&human, "Used:", "used label")?;
        ensure_contains(&human, "Slack:", "slack label")?;
        ensure_contains(&human, "Utilization:", "utilization label")?;
        ensure_contains(&human, "Rate (R):", "rate label")?;
        ensure_contains(&human, "Distortion (D):", "distortion label")
    }

    #[test]
    fn section_budget_report_computes_utilization() -> TestResult {
        let section = SectionBudgetReport::new("procedural", 1200, 900);
        ensure(
            (section.utilization_percent() - 75.0).abs() < 0.01,
            format!(
                "expected 75% utilization, got {}%",
                section.utilization_percent()
            ),
        )?;
        ensure(
            section.slack() == 300,
            format!("expected slack 300, got {}", section.slack()),
        )
    }

    #[test]
    fn section_budget_report_to_json() -> TestResult {
        let section = SectionBudgetReport::new("decisions", 800, 600).with_candidates(5);
        let json = section.to_json();

        ensure_contains(&json, "\"name\":\"decisions\"", "name")?;
        ensure_contains(&json, "\"quotaTokens\":800", "quota")?;
        ensure_contains(&json, "\"usedTokens\":600", "used")?;
        ensure_contains(&json, "\"slackTokens\":200", "slack")?;
        ensure_contains(&json, "\"candidateCount\":5", "candidates")
    }

    #[test]
    fn pack_cache_prewarm_enforces_generation_and_pressure() -> TestResult {
        let candidate = PackCandidate::new(candidate_input(
            memory_id(0x7101),
            PackSection::ProceduralRules,
            "Run cargo fmt before release.",
            8,
            vec![provenance("file://AGENTS.md")?],
            "matches release workflow",
        )?)
        .map_err(|error| format!("candidate rejected: {error:?}"))?;
        let budget = TokenBudget::new(120).map_err(|error| format!("budget: {error:?}"))?;
        let draft = assemble_draft("prepare release", budget, vec![candidate])
            .map_err(|error| format!("draft: {error:?}"))?;
        let hotset = PackHotset::from_draft(&draft, 7);

        let stale = prewarm_pack_hotset(
            &hotset,
            PackCacheGovernor::new(8, CacheBudget::new(8, 64_000)),
        );
        ensure_equal(
            &stale.status,
            &PackCacheStatus::StaleGeneration,
            "stale generation status",
        )?;
        ensure_equal(
            &stale.fallback_reason,
            &Some("generation_mismatch"),
            "stale fallback reason",
        )?;

        let pressure = prewarm_pack_hotset(
            &hotset,
            PackCacheGovernor::new(7, CacheBudget::new(10, 1_000).with_watermarks(0.5, 0.8))
                .with_current_usage(9, 900),
        );
        ensure_equal(
            &pressure.status,
            &PackCacheStatus::Bypassed,
            "critical pressure status",
        )?;
        ensure_equal(
            &pressure.memory_pressure,
            &MemoryPressure::Critical,
            "critical pressure level",
        )?;
        ensure_equal(
            &pressure.fallback_reason,
            &Some("memory_pressure_critical"),
            "critical fallback reason",
        )
    }

    #[test]
    fn pack_cache_hotset_section_key_uses_radix_memory_id_order() -> TestResult {
        let draft = draft_from_candidates(vec![
            candidate_with_content(3, 0.8, 0.5, 10, "third release rule")?,
            candidate_with_content(1, 0.8, 0.5, 10, "first release rule")?,
            candidate_with_content(2, 0.8, 0.5, 10, "second release rule")?,
        ])?;
        let hotset = PackHotset::from_draft(&draft, 13);
        let actual = hotset
            .entries()
            .iter()
            .find(|entry| entry.kind == PackHotsetEntryKind::PackSection)
            .ok_or_else(|| "expected pack-section hotset entry".to_owned())?;
        let memory_ids = vec![
            memory_id(1).to_string(),
            memory_id(2).to_string(),
            memory_id(3).to_string(),
        ];
        let expected =
            PackHotsetEntry::pack_section(PackSection::ProceduralRules, &memory_ids, 30, 13, 3);

        ensure_equal(actual, &expected, "pack-section hotset entry")
    }

    #[test]
    fn pack_cache_on_and_off_selection_outputs_are_equivalent() -> TestResult {
        let candidates = vec![
            PackCandidate::new(candidate_input(
                memory_id(0x7201),
                PackSection::ProceduralRules,
                "Run cargo fmt before release.",
                8,
                vec![provenance("file://AGENTS.md")?],
                "formatting rule",
            )?)
            .map_err(|error| format!("candidate rejected: {error:?}"))?,
            PackCandidate::new(candidate_input(
                memory_id(0x7202),
                PackSection::Decisions,
                "Release checks use rch for cargo invocations.",
                9,
                vec![provenance(
                    "file://docs/adr/0017-swarm-scale-resource-governance.md",
                )?],
                "verification rule",
            )?)
            .map_err(|error| format!("candidate rejected: {error:?}"))?,
        ];
        let budget = TokenBudget::new(120).map_err(|error| format!("budget: {error:?}"))?;

        let cold = assemble_draft_with_profile(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates.clone(),
        )
        .map_err(|error| format!("cold draft: {error:?}"))?;
        let (warm, report) = assemble_draft_with_cache_governor(
            ContextPackProfile::Balanced,
            "prepare release",
            budget,
            candidates,
            11,
            PackCacheGovernor::new(11, CacheBudget::new(8, 64_000)),
        )
        .map_err(|error| format!("warm draft: {error:?}"))?;

        let cold_ids: Vec<_> = cold.items.iter().map(|item| item.memory_id).collect();
        let warm_ids: Vec<_> = warm.items.iter().map(|item| item.memory_id).collect();
        ensure_equal(&warm_ids, &cold_ids, "cache-on selected memory ids")?;
        ensure_equal(&warm.omitted, &cold.omitted, "cache-on omissions")?;
        ensure_equal(
            &warm.selection_audit.selected_items,
            &cold.selection_audit.selected_items,
            "cache-on certificate selected items",
        )?;
        ensure_equal(&report.status, &PackCacheStatus::Warm, "cache status")?;
        ensure(
            report.benchmark.warm_latency_us < report.benchmark.cold_latency_us,
            "cache prewarm reports latency win",
        )
    }

    #[test]
    fn pack_cache_hotset_entries_do_not_store_secret_content() -> TestResult {
        let raw_secret = "ANTHROPIC_API_KEY=sk-ant-api03-secret";
        let candidate = PackCandidate::new(candidate_input(
            memory_id(0x7301),
            PackSection::Evidence,
            format!("Rotate {raw_secret} before sharing support bundles."),
            12,
            vec![provenance("file://support.md")?],
            "secret-bearing evidence must be redacted before packing",
        )?)
        .map_err(|error| format!("candidate rejected: {error:?}"))?;
        let budget = TokenBudget::new(120).map_err(|error| format!("budget: {error:?}"))?;
        let draft = assemble_draft("support bundle", budget, vec![candidate])
            .map_err(|error| format!("draft: {error:?}"))?;
        let hotset = PackHotset::from_draft(&draft, 3);
        let report = prewarm_pack_hotset(
            &hotset,
            PackCacheGovernor::new(3, CacheBudget::new(8, 64_000)),
        );
        let json = report.data_json().to_string();

        ensure(
            hotset
                .entries()
                .iter()
                .all(PackHotsetEntry::is_redaction_safe),
            "all pack hotset entries should be content-free",
        )?;
        ensure(
            !json.contains(raw_secret),
            "cache report must not contain raw secret",
        )?;
        ensure(
            !json.contains("sk-ant-api03-secret"),
            "cache report must not contain secret suffix",
        )?;
        ensure_equal(&report.status, &PackCacheStatus::Warm, "cache status")
    }

    proptest! {
        #[test]
        fn section_budget_report_to_json_escapes_weird_section_names(
            name in weird_section_name_strategy(),
        ) {
            let section = SectionBudgetReport::new(name.clone(), 800, 600).with_candidates(5);
            let json = section.to_json();
            let expected_name = serde_json::to_string(&name)
                .map_err(|error| TestCaseError::fail(format!("failed to serialize expected name: {error}")))?;
            let parsed: serde_json::Value = serde_json::from_str(&json)
                .map_err(|error| TestCaseError::fail(format!("section JSON must parse: {error}; json={json:?}")))?;

            prop_assert!(
                json.contains(&format!("\"name\":{expected_name}")),
                "section JSON should contain escaped name {expected_name}, got {json}",
            );
            prop_assert_eq!(parsed["name"].as_str(), Some(name.as_str()));
            prop_assert_eq!(parsed["quotaTokens"].as_u64(), Some(800));
            prop_assert_eq!(parsed["usedTokens"].as_u64(), Some(600));
            prop_assert_eq!(parsed["slackTokens"].as_u64(), Some(200));
            prop_assert_eq!(parsed["candidateCount"].as_u64(), Some(5));
        }
    }

    #[test]
    fn compute_rate_distortion_helper() -> TestResult {
        let report = compute_rate_distortion(4000, 3500, 15, 3);
        ensure(
            report.budget_tokens == 4000,
            format!("expected budget 4000, got {}", report.budget_tokens),
        )?;
        ensure(
            report.used_tokens == 3500,
            format!("expected used 3500, got {}", report.used_tokens),
        )?;
        ensure(
            report.included_candidates == 15,
            format!("expected 15 included, got {}", report.included_candidates),
        )?;
        ensure(
            report.omitted_candidates == 3,
            format!("expected 3 omitted, got {}", report.omitted_candidates),
        )
    }

    #[test]
    fn rate_distortion_zero_budget_handles_gracefully() -> TestResult {
        let report = RateDistortionReport::new(0, 0);
        ensure(
            report.rate == 0.0,
            format!("expected rate 0 for zero budget, got {}", report.rate),
        )?;
        ensure(
            report.slack() == 0,
            format!("expected slack 0, got {}", report.slack()),
        )
    }
}