Method assemble

core/src/context/assembler.rs:145–220

(&self, results: &[ContextResult])

    }

    pub fn assemble(&self, results: &[ContextResult]) -> ContextAssembly {
        let mut deduped: HashMap<String, ContextItem> = HashMap::new();
        let mut source_count = 0usize;

        for result in results {
            for item in &result.items {
                source_count += 1;
                let key = dedupe_key(item);
                match deduped.get(&key) {
                    Some(existing)
                        if ranking_score(existing)
                            .total_cmp(&ranking_score(item))
                            .then_with(|| existing.relevance.total_cmp(&item.relevance))
                            .is_ge() => {}
                    _ => {
                        deduped.insert(key, item.clone());
                    }
                }
            }
        }

        let mut items = deduped.into_values().collect::<Vec<_>>();
        items.sort_by(|a, b| {
            ranking_score(b)
                .total_cmp(&ranking_score(a))
                .then_with(|| b.relevance.total_cmp(&a.relevance))
                .then_with(|| estimated_tokens(a).cmp(&estimated_tokens(b)))
                .then_with(|| a.id.cmp(&b.id))
        });

        let mut selected = Vec::new();
        let mut total_tokens = 0usize;
        let mut truncated = source_count > items.len();
        let mut source_item_counts: HashMap<String, usize> = HashMap::new();
        let mut source_token_counts: HashMap<String, usize> = HashMap::new();

        for item in items {
            if selected.len() >= self.budget.max_items {
                truncated = true;
                break;
            }

            let item_tokens = estimated_tokens(&item);
            if total_tokens + item_tokens > self.budget.max_tokens {
                truncated = true;
                continue;
            }

            let source_key = source_policy_key(&item);
            if let Some(max_items) = self.source_policy.max_items_per_source {
                let count = source_item_counts.get(&source_key).copied().unwrap_or(0);
                if count >= max_items {
                    truncated = true;
                    continue;
                }
            }
            if let Some(max_tokens) = self.source_policy.max_tokens_per_source {
                let source_tokens = source_token_counts.get(&source_key).copied().unwrap_or(0);