Preserve legacy Persona checkpoints and refuse blank recovery (#3925)

* Preserve selected legacy checkpoints and refuse blank resident recovery

* fix: resolve checkpoint adoption Clippy findings

Author: joelteply

core/continuum-core/src/bin/continuum.rs

@@ -94,10 +94,11 @@ impl ServiceModule for ShouldRespondModule {
                 // Run the persona's continuous mind over the burst. The decision
                 // is the OUTPUT of cognition; `None` (nothing won attention
                 // strongly enough to externalize) is effective silence = Pass.
-                let room = crate::identity::ActivityRoom::from_uuid(p.room_id)
-                    .map_err(|_| {
-                        format!("{SHOULD_RESPOND_COMMAND}: room_id must be a real (non-nil) room (#425)")
-                    })?;
+                let room = crate::identity::ActivityRoom::from_uuid(p.room_id).map_err(|_| {
+                    format!(
+                        "{SHOULD_RESPOND_COMMAND}: room_id must be a real (non-nil) room (#425)"
+                    )
+                })?;
                 let workspace = cycle
                     .run_framed(
                         crate::cognition::workspace::Burst::raw_in(room, p.burst),
@@ -163,22 +164,24 @@ mod tests {
 
     fn registry_with_ivar(persona: Uuid) -> Arc<PersonaWorkspaceRegistry> {
         let registry = Arc::new(PersonaWorkspaceRegistry::new());
-        registry.get_or_build(PersonaBrainConfig {
-            persona_id: persona,
-            persona_name: "Ivar".to_string(),
-            system_prompt: "You are Ivar, an engineer on the grid.".to_string(),
-            admission: seed_admission(1_000_000_000),
-            adapter: Arc::new(HeuristicInferenceAdapter::new()),
-            capacity: None,
-            grounding_sources: Vec::new(),
-            embedder: None,
-            tool_executor: None,
-            context_window: crate::cognition::serving_plan::MIN_SERVE_CTX,
-            // Harness: synchronous perception (deferral is a live-path concern).
-            defer_recall: false,
-            defer_grounding: false,
-            suppress_recall: false,
-        });
+        registry
+            .get_or_build(PersonaBrainConfig {
+                persona_id: persona,
+                persona_name: "Ivar".to_string(),
+                system_prompt: "You are Ivar, an engineer on the grid.".to_string(),
+                admission: seed_admission(1_000_000_000),
+                adapter: Arc::new(HeuristicInferenceAdapter::new()),
+                capacity: None,
+                grounding_sources: Vec::new(),
+                embedder: None,
+                tool_executor: None,
+                context_window: crate::cognition::serving_plan::MIN_SERVE_CTX,
+                // Harness: synchronous perception (deferral is a live-path concern).
+                defer_recall: false,
+                defer_grounding: false,
+                suppress_recall: false,
+            })
+            .expect("test: resident checkpoint is readable");
         registry
     }
 

core/continuum-core/src/cognition/persona_workspace.rs

@@ -102,7 +102,12 @@ pub fn record_focus(persona: Uuid) {
 
 /// Level for a faculty pulse: full while fresh, fading linearly to 0 over the
 /// window; `None` when nothing fired within it (an honest "awaiting").
-fn faculty_level(persona: Uuid, axis: &'static str, window: Duration, full_scale: u64) -> Option<u8> {
+fn faculty_level(
+    persona: Uuid,
+    axis: &'static str,
+    window: Duration,
+    full_scale: u64,
+) -> Option<u8> {
     let pulse = FACULTY_PULSE.lock().unwrap_or_else(|e| e.into_inner());
     let (n, at) = pulse.get(&(persona, axis))?;
     let age = at.elapsed();
@@ -244,8 +249,7 @@ pub(crate) fn sample_vitals(
         let mut vitals = BTreeMap::new();
         vitals.insert(
             "activity".to_string(),
-            pct_u64(delta, ACT_FULL_SCALE_TICKS)
-                .max(pct_u64(act_pulse, ACT_PULSE_FULL_SCALE)),
+            pct_u64(delta, ACT_FULL_SCALE_TICKS).max(pct_u64(act_pulse, ACT_PULSE_FULL_SCALE)),
         );
         vitals.insert(
             "queue".to_string(),
@@ -433,12 +437,21 @@ mod tests {
         let p = Uuid::from_u128(0x77);
         assert!(faculty_level(p, "reason", Duration::from_secs(60), 1).is_none());
         record_reasoning(p);
-        assert_eq!(faculty_level(p, "reason", Duration::from_secs(60), 1), Some(100));
+        assert_eq!(
+            faculty_level(p, "reason", Duration::from_secs(60), 1),
+            Some(100)
+        );
         record_recall(p, 3);
-        assert_eq!(faculty_level(p, "recall", Duration::from_secs(60), 6), Some(50));
+        assert_eq!(
+            faculty_level(p, "recall", Duration::from_secs(60), 6),
+            Some(50)
+        );
         assert!(faculty_level(p, "recall", Duration::from_millis(0), 6).is_none());
         record_focus(p);
-        assert_eq!(faculty_level(p, "focus", Duration::from_secs(60), 1), Some(100));
+        assert_eq!(
+            faculty_level(p, "focus", Duration::from_secs(60), 1),
+            Some(100)
+        );
     }
 
     use super::*;
@@ -452,23 +465,25 @@ mod tests {
     /// from `identity.peer_id.as_uuid()`.
     fn registry_with(peer_id: Uuid) -> std::sync::Arc<PersonaWorkspaceRegistry> {
         let registry = std::sync::Arc::new(PersonaWorkspaceRegistry::new());
-        registry.get_or_build(PersonaBrainConfig {
-            persona_id: peer_id,
-            persona_name: "Asha".to_string(),
-            system_prompt: "You are Asha.".to_string(),
-            admission: std::sync::Arc::new(AdmissionState::new(std::sync::Arc::new(
-                RecallMetadataRegistry::new(),
-            ))),
-            adapter: std::sync::Arc::new(HeuristicInferenceAdapter::new()),
-            capacity: None,
-            grounding_sources: Vec::new(),
-            embedder: None,
-            tool_executor: None,
-            context_window: crate::cognition::serving_plan::MIN_SERVE_CTX,
-            defer_recall: false,
-            defer_grounding: false,
-            suppress_recall: false,
-        });
+        registry
+            .get_or_build(PersonaBrainConfig {
+                persona_id: peer_id,
+                persona_name: "Asha".to_string(),
+                system_prompt: "You are Asha.".to_string(),
+                admission: std::sync::Arc::new(AdmissionState::new(std::sync::Arc::new(
+                    RecallMetadataRegistry::new(),
+                ))),
+                adapter: std::sync::Arc::new(HeuristicInferenceAdapter::new()),
+                capacity: None,
+                grounding_sources: Vec::new(),
+                embedder: None,
+                tool_executor: None,
+                context_window: crate::cognition::serving_plan::MIN_SERVE_CTX,
+                defer_recall: false,
+                defer_grounding: false,
+                suppress_recall: false,
+            })
+            .expect("test: resident checkpoint is readable");
         registry
     }
 

core/continuum-core/src/cognition/persona_workspace/checkpoint_adoption.rs

@@ -397,8 +397,9 @@ impl PersonaSpawnSupervisor {
     /// is edge-triggered, keyed by `until_ms` so a renewed hold announces
     /// itself afresh.
     fn probe_held_out_once(agent: &str, hold: &crate::persona::roster_hold::RosterHold) {
-        static PROBED: std::sync::OnceLock<std::sync::Mutex<std::collections::HashSet<(String, u64)>>> =
-            std::sync::OnceLock::new();
+        static PROBED: std::sync::OnceLock<
+            std::sync::Mutex<std::collections::HashSet<(String, u64)>>,
+        > = std::sync::OnceLock::new();
         let set = PROBED.get_or_init(|| std::sync::Mutex::new(std::collections::HashSet::new()));
         let Ok(mut guard) = set.lock() else {
             return; // poisoned = a prior panic mid-insert; skip the probe, never the filter
@@ -511,12 +512,16 @@ impl PersonaSpawnSupervisor {
         let plans: Vec<crate::persona::spawner_module::MaterializedPersonaPlan> = unattended
             .iter()
             .zip(profiles)
-            .map(|(rt, profile)| crate::persona::spawner_module::MaterializedPersonaPlan {
-                role: desired.role,
-                instance:
-                    crate::modules::persona_instance_manager::PersonaInstanceInfo::from_runtime(rt),
-                profile,
-            })
+            .map(
+                |(rt, profile)| crate::persona::spawner_module::MaterializedPersonaPlan {
+                    role: desired.role,
+                    instance:
+                        crate::modules::persona_instance_manager::PersonaInstanceInfo::from_runtime(
+                            rt,
+                        ),
+                    profile,
+                },
+            )
             .collect();
 
         // The reconciler's other entrance passes the SAME operator-intent
@@ -705,6 +710,9 @@ fn supervisor_error_facts(err: &SupervisorError) -> (Option<usize>, RoleId) {
         | SupervisorError::AdapterWarmup {
             slot_index, role, ..
         }
+        | SupervisorError::WorkspaceRegistration {
+            slot_index, role, ..
+        }
         | SupervisorError::RuntimeMissing {
             slot_index, role, ..
         } => (Some(*slot_index), *role),
@@ -775,7 +783,9 @@ mod tests {
                 &self,
                 _profile: &crate::persona::inference_profile::PersonaInferenceProfile,
             ) -> Result<Arc<dyn crate::ai::adapter::AIProviderAdapter>, String> {
-                panic!("factory must not be consulted when the registry has no unattended citizens");
+                panic!(
+                    "factory must not be consulted when the registry has no unattended citizens"
+                );
             }
         }
 

core/continuum-core/src/cognition/should_respond_module.rs

@@ -5046,7 +5046,9 @@ mod tests {
             defer_grounding: false,
             suppress_recall: false,
         };
-        crate::cognition::persona_workspace::global().register_from_cfg(cfg);
+        crate::cognition::persona_workspace::global()
+            .register_from_cfg(cfg)
+            .expect("test: resident checkpoint is readable");
 
         // One held (Claimed) card in her hands. A NON-bench title so the
         // act-question resolves no staged checkout (no hands re-root needed).