Skip to main content

hippmem_engine/
feedback_api.rs

1//! Engine::feedback — usage feedback API.
2//!
3//! Corresponds to 05#feedback, 09 §4.6. Records usage signals to activation_log
4//! (driving Hebbian reinforcement/decay, consumed by consolidate) and updates each
5//! memory's `usage_score` (0.3.0: confirmations/references raise it, rejections
6//! lower it — retrieval energy is weighted by usage_score).
7
8use crate::signals::usage_delta;
9use crate::{Engine, EngineError, EngineResult, FeedbackInput};
10use hippmem_core::model::unit::MemoryUnit;
11use hippmem_core::score::UnitScore;
12use hippmem_core::time::{Clock, SystemClock};
13use hippmem_store::activation_log::{ActivationLogger, ActivationRecord};
14use hippmem_store::kv::KvStore;
15
16impl Engine {
17    /// Records a usage feedback signal and updates usage_score of the referenced memories.
18    ///
19    /// The signal is persisted to activation_log for consumption by the
20    /// background Hebbian/decay worker; usage_score changes take effect on the
21    /// next retrieval (energy formula, 03 §4).
22    pub fn feedback(&self, input: FeedbackInput) -> EngineResult<()> {
23        let clock = SystemClock;
24        let now = clock.now();
25
26        let logger = ActivationLogger::new(self.store.db_arc());
27        let signal = signal_to_string(&input.signal);
28        let rec = ActivationRecord {
29            retrieval_id: input.retrieval_id,
30            // P1 回归:保留完整 u128 id(截断会导致下游 Hebbian/RecentActivation 失配)
31            used_memory_ids: input.used_memory_ids.iter().map(|id| id.0).collect(),
32            signal: signal.clone(),
33            recorded_at_ms: now.as_i64(),
34        };
35        logger
36            .record(&rec)
37            .map_err(|e| EngineError::Internal(format!("activation_log: {}", e)))?;
38
39        // 0.3.0: usage_score 更新(确认 ↑ / 拒绝 ↓,clamp [0,1])
40        let delta = usage_delta(&signal);
41        if delta != 0.0 && !input.used_memory_ids.is_empty() {
42            let kv = KvStore::new(self.store.db_arc());
43            for id in &input.used_memory_ids {
44                if let Some(raw) = kv
45                    .get(&id.0)
46                    .map_err(|e| EngineError::Store(e.to_string()))?
47                {
48                    let (mut unit, _): (MemoryUnit, _) =
49                        bincode::serde::decode_from_slice(&raw, bincode::config::standard())
50                            .map_err(|e| EngineError::Internal(e.to_string()))?;
51                    let new_usage = (unit.activation.usage_score.value() + delta).clamp(0.0, 1.0);
52                    unit.activation.usage_score = UnitScore::new(new_usage);
53                    let encoded = bincode::serde::encode_to_vec(&unit, bincode::config::standard())
54                        .map_err(|e| EngineError::Internal(e.to_string()))?;
55                    kv.put(id.0, &encoded)
56                        .map_err(|e| EngineError::Store(e.to_string()))?;
57                }
58            }
59        }
60
61        Ok(())
62    }
63}
64
65fn signal_to_string(s: &crate::UsageSignal) -> String {
66    match s {
67        crate::UsageSignal::Referenced => "Referenced".into(),
68        crate::UsageSignal::UserConfirmedCorrect => "UserConfirmedCorrect".into(),
69        crate::UsageSignal::TaskSucceeded => "TaskSucceeded".into(),
70        crate::UsageSignal::UserRejected => "UserRejected".into(),
71    }
72}