Struct RecentCaptureChecker 

pub struct RecentCaptureChecker {
    cache: RwLock<LruCache<String, CacheEntry>>,
    ttl: Duration,
}

Checker for recently captured content.

How it works

1. Maintains an LRU cache mapping content hashes to capture info
2. When checking, looks up the hash in the cache
3. Returns a match if found and not expired (within TTL window)
4. Automatically evicts expired entries and maintains LRU ordering

Thread Safety

Uses RwLock for interior mutability, allowing concurrent reads and exclusive writes. Safe for use across async tasks.

Lock Poisoning

Lock poisoning is handled with fail-open semantics: if the lock is poisoned (due to a panic in another thread), operations return None (for checks) or silently skip (for records). This is intentional:

• Deduplication is a performance optimization, not a correctness requirement
• Failing to detect a duplicate just means we capture twice (safe)
• Blocking all captures due to a transient panic would be worse

Example

use subcog::services::deduplication::RecentCaptureChecker;
use std::time::Duration;

let checker = RecentCaptureChecker::new(1000, Duration::from_secs(300));

// Record a capture
checker.record("content", MemoryId::new("id1"), Namespace::Decisions, "project");

// Check if same content was recently captured
let result = checker.check("content", Namespace::Decisions);
assert!(result.is_some());

Fields

cache: RwLock<LruCache<String, CacheEntry>>

LRU cache mapping content hash to capture entry. Uses RwLock for thread-safe interior mutability.

ttl: Duration

Time-to-live for cache entries.

Implementations

impl RecentCaptureChecker

pub fn new(capacity: usize, ttl: Duration) -> Self

Creates a new recent capture checker.

Arguments

• capacity - Maximum number of entries in the cache
• ttl - How long entries remain valid

Panics

Panics if capacity is 0.

pub fn default_settings() -> Self

Creates a checker with default settings.

Default: 1000 entries, 5 minute TTL.

pub fn check( &self, content: &str, namespace: Namespace, ) -> Option<(MemoryId, String)>

Checks if content was recently captured in the given namespace.

Arguments

• content - The content to check
• namespace - The namespace to check within

Returns

Returns Some((MemoryId, URN)) if content was recently captured, None otherwise.

Example

let result = checker.check("content", Namespace::Decisions);
match result {
    Some((id, urn)) => println!("Recently captured: {}", urn),
    None => println!("Not recently captured"),
}

pub fn record( &self, content: &str, memory_id: &MemoryId, namespace: Namespace, domain: &str, )

Records a successful capture for future duplicate detection.

Arguments

• content - The captured content
• memory_id - The ID assigned to the captured memory
• namespace - The namespace the content was captured to
• domain - The domain the content was captured to

Example

checker.record(
    "Use PostgreSQL for storage",
    MemoryId::new("mem-123"),
    Namespace::Decisions,
    "project",
);

pub fn record_by_hash( &self, content_hash: &str, memory_id: &MemoryId, namespace: Namespace, domain: &str, )

Records a capture using just the content hash.

Useful when the hash has already been computed.

Arguments

• content_hash - The pre-computed content hash
• memory_id - The ID assigned to the captured memory
• namespace - The namespace the content was captured to
• domain - The domain the content was captured to

Trait Implementations

impl Default for RecentCaptureChecker

fn default() -> Self

Returns the “default value” for a type.