Module context 

Bounded context assembly for retrieval results.

This module provides BundleAccumulator, a sliding window accumulator that bounds retrieval context size by recency and salience instead of flat accumulation.

Purpose

When retrieving episodes and patterns for downstream prompts (e.g., LLM context), flat accumulation can result in:

• Excessive token usage (too many items)
• Irrelevant items (low-quality matches included)
• Stale context (old items dominating recent ones)

BundleAccumulator addresses these by:

• Capping the number of items via a sliding window
• Prioritizing by combined recency + salience scoring
• Evicting lowest-priority items when capacity exceeded

DAG-Based State Management (WG-134)

The dag submodule provides DAG-based state management achieving ~86% token reduction by deduplicating shared context between episodes:

• StateDag: Manages shared context nodes
• DagContextAssembler: Assembles minimal deduplicated context

Architecture

Retrieval Results
       |
       v
  ContextItem (Episode/Pattern + Salience)
       |
       v
  BundleAccumulator (Sliding Window)
       |  - Check salience threshold
       |  - Compute priority = recency_weight * recency + salience_weight * salience
       |  - Evict lowest priority if full
       v
  Bounded Bundle (sorted by priority)
       |
       v
  DagContextAssembler (WG-134)
       |  - Deduplicate shared context
       |  - ~86% token reduction
       v
  Downstream Prompt

Quick Start

use do_memory_core::context::{BundleAccumulator, BundleConfig, ContextItem};
use do_memory_core::episode::Episode;
use do_memory_core::TaskContext;
use do_memory_core::types::TaskType;
use std::sync::Arc;

// Create accumulator with default config (20 items max)
let mut accumulator = BundleAccumulator::default_config();

// Add retrieved episodes with their salience scores
let episode = Episode::new(
    "Fix authentication bug".to_string(),
    TaskContext::default(),
    TaskType::Debugging,
);
let item = ContextItem::from_episode(Arc::new(episode), 0.85);
accumulator.add(item);

// Finalize bundle for prompt
let bundle = accumulator.to_bundle();
println!("Bundle contains {} items for prompt", bundle.len());

Configuration Options

use do_memory_core::context::BundleConfig;

// Token-efficient: smaller bundle, higher quality threshold
let token_config = BundleConfig::token_efficient();

// Comprehensive: larger bundle, lower threshold
let full_config = BundleConfig::comprehensive();

// Custom: tune for specific needs
let custom = BundleConfig {
    max_items: 15,            // Allow 15 items
    recency_weight: 0.6,      // Favor recent items
    salience_weight: 0.3,     // Still consider retrieval score
    min_salience_threshold: 0.3, // Reject very low salience
    recency_half_life_days: 14.0, // Recent = last 2 weeks
};

Integration with Retrieval

The accumulator is designed to sit between retrieval results and prompt construction:

use do_memory_core::memory::SelfLearningMemory;
use do_memory_core::context::{BundleAccumulator, BundleConfig};
use do_memory_core::TaskContext;

// Retrieve episodes (unbounded)
let episodes = memory.retrieve_relevant_context(
    "Implement OAuth2".to_string(),
    TaskContext::default(),
    50,  // May retrieve up to 50
).await;

// Create bounded bundle
let bundle = BundleAccumulator::from_episodes_with_config(
    episodes,
    BundleConfig::token_efficient(),
    |ep| ep.reward.as_ref().map_or(0.5, |r| r.total),
);

// bundle.len() <= 10 (bounded for token efficiency)

Modules

• types: Core types (ContextItem, BundleConfig, BundleStats)
• accumulator: BundleAccumulator implementation
• scoring: Priority and recency scoring functions
• dag: DAG-based state management (WG-134, ~86% token reduction)

Re-exports

pub use accumulator::BundleAccumulator;

pub use scoring::calculate_priority_score;

pub use scoring::calculate_recency_score;

pub use scoring::compare_by_priority;

pub use scoring::compare_by_recency;

pub use scoring::compare_by_salience;

pub use types::AddResult;

pub use types::BundleConfig;

pub use types::BundleStats;

pub use types::ContextItem;

pub use types::ContextItemType;

pub use dag::AssembledContext;

pub use dag::DagAssemblyConfig;

pub use dag::DagContextAssembler;

pub use dag::DagStats;

pub use dag::EdgeMetadata;

pub use dag::EdgeType;

pub use dag::NodeId;

pub use dag::StateDag;

pub use dag::StateEdge;

pub use dag::StateNode;

pub use dag::StateNodeType;

Modules

accumulator

Sliding window accumulator for bounded context assembly.

dag

DAG-based state management for episode context (WG-134).

scoring

Scoring functions for context bundle items.

types

Types for bounded context assembly.