1#[cfg(test)]
2mod recovery_tests {
3 use super::*;
4 #[test]
5 fn interrupted_move_restores_source_and_target_from_either_entry_point() {
6 for open_source in [true, false] {
7 let root = tempfile::tempdir().unwrap();
8 let source = MemoryStore::open(root.path(), "source", "original-source").unwrap();
9 let target = MemoryStore::open(root.path(), "target", "original-target").unwrap();
10 let expected = target.files().unwrap();
11 let mut next = expected.clone();
12 next.insert("system.md".into(), "migrated persona".into());
13 let guard = source.lock().unwrap();
14 target.publish_pending(&guard, &expected, &next).unwrap();
15 target.prepare_move(&source, &guard).unwrap();
16 guard.release().unwrap();
17 if open_source {
18 MemoryStore::existing(root.path(), "source").unwrap();
19 } else {
20 MemoryStore::existing(root.path(), "target").unwrap();
21 }
22 assert_eq!(
23 MemoryStore::existing(root.path(), "source")
24 .unwrap()
25 .meta
26 .created_at,
27 "original-source"
28 );
29 assert_eq!(
30 MemoryStore::existing(root.path(), "target")
31 .unwrap()
32 .files()
33 .unwrap(),
34 expected
35 );
36 }
37 }
38}
39use crate::state::{Config, LockGuard, StateStore};
40use serde::{Deserialize, Serialize};
41use sha2::{Digest, Sha256};
42use std::{
43 fs,
44 io::Write,
45 path::{Path, PathBuf},
46 time::Duration,
47};
48
49#[derive(Debug, thiserror::Error)]
50#[error("memory: {0}")]
51pub struct MemoryError(pub String);
52impl From<std::io::Error> for MemoryError {
53 fn from(error: std::io::Error) -> Self {
54 Self(error.to_string())
55 }
56}
57impl From<serde_json::Error> for MemoryError {
58 fn from(error: serde_json::Error) -> Self {
59 Self(error.to_string())
60 }
61}
62impl From<crate::state::StateError> for MemoryError {
63 fn from(error: crate::state::StateError) -> Self {
64 Self(error.to_string())
65 }
66}
67#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
68#[serde(deny_unknown_fields)]
69pub struct EmbeddingMeta {
70 pub model: String,
71 pub dimension: usize,
72}
73#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
74#[serde(rename_all = "camelCase", deny_unknown_fields)]
75pub struct MemoryMeta {
76 pub schema_version: u8,
77 pub model_id: String,
78 pub created_at: String,
79 #[serde(skip_serializing_if = "Option::is_none")]
80 pub embedding: Option<EmbeddingMeta>,
81 #[serde(skip_serializing_if = "Option::is_none")]
82 pub embedding_unsupported: Option<bool>,
83}
84impl MemoryMeta {
85 pub fn validate(&self) -> Result<(), MemoryError> {
86 if self.schema_version != 1
87 || self.model_id.is_empty()
88 || self.model_id.len() > 8192
89 || self.created_at.is_empty()
90 || self.created_at.len() > 1024
91 || self.embedding_unsupported == Some(false)
92 || self.embedding.as_ref().is_some_and(|embedding| {
93 embedding.model.is_empty()
94 || embedding.model.len() > 8192
95 || embedding.dimension == 0
96 || embedding.dimension > 100000
97 })
98 {
99 return Err(MemoryError("invalid metadata".into()));
100 }
101 Ok(())
102 }
103}
104pub fn memory_slug(id: &str, windows: bool) -> Result<String, MemoryError> {
105 if id.len() > 1024 * 1024 {
106 return Err(MemoryError("model id exceeds limit".into()));
107 }
108 let mut slug = String::new();
109 for character in id.trim().to_lowercase().chars() {
110 let character = if character.is_ascii_alphanumeric() || "._-".contains(character) {
111 character
112 } else {
113 '-'
114 };
115 if character != '-' || !slug.ends_with('-') {
116 slug.push(character);
117 }
118 }
119 slug = slug.trim_matches(['-', '.']).into();
120 let stem = slug.split('.').next().unwrap_or("");
121 if windows
122 && (["con", "prn", "aux", "nul"].contains(&stem)
123 || (stem.starts_with("com") || stem.starts_with("lpt"))
124 && stem.len() == 4
125 && matches!(stem.as_bytes()[3], b'1'..=b'9'))
126 {
127 slug = format!("x-{slug}");
128 }
129 if slug.is_empty() {
130 return Err(MemoryError("model id has no filesystem-safe slug".into()));
131 }
132 if slug.len() > 128 {
133 let digest = format!("{:x}", Sha256::digest(slug.as_bytes()));
134 slug = format!(
135 "{}-{}",
136 slug[..111].trim_end_matches(['-', '.']),
137 &digest[..16]
138 );
139 }
140 Ok(slug)
141}
142pub(crate) fn private_directory(path: &Path) -> Result<(), MemoryError> {
143 match fs::symlink_metadata(path) {
144 Ok(metadata) if metadata.is_dir() && !metadata.file_type().is_symlink() => (),
145 Ok(_) => {
146 return Err(MemoryError(
147 "directory is symlinked or not a directory".into(),
148 ));
149 }
150 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
151 if let Some(parent) = path.parent() {
152 private_directory(parent)?;
153 }
154 let builder = fs::DirBuilder::new();
155 #[cfg(unix)]
156 let mut builder = builder;
157 #[cfg(unix)]
158 {
159 use std::os::unix::fs::DirBuilderExt;
160 builder.mode(0o700);
161 }
162 match builder.create(path) {
163 Ok(()) => (),
164 Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {
165 return private_directory(path);
166 }
167 Err(error) => return Err(error.into()),
168 }
169 }
170 Err(error) => return Err(error.into()),
171 }
172 Ok(())
173}
174pub(crate) fn owned_directory(path: &Path) -> Result<(), MemoryError> {
175 private_directory(path)?;
176 #[cfg(unix)]
177 {
178 use std::os::unix::fs::PermissionsExt;
179 crate::secure_fs::Directory::open(path)?
180 .dir()?
181 .open(".")?
182 .into_std()
183 .set_permissions(fs::Permissions::from_mode(0o700))?;
184 }
185 Ok(())
186}
187pub(crate) fn atomic_file(path: &Path, bytes: &[u8]) -> Result<(), MemoryError> {
188 let parent = path
189 .parent()
190 .ok_or_else(|| MemoryError("missing file parent".into()))?;
191 private_directory(parent)?;
192 let mut staged = tempfile::NamedTempFile::new_in(parent)?;
193 staged.write_all(bytes)?;
194 staged.as_file().sync_all()?;
195 staged
196 .persist(path)
197 .map_err(|error| MemoryError(error.to_string()))?;
198 #[cfg(unix)]
199 fs::File::open(parent)?.sync_all()?;
200 Ok(())
201}
202#[derive(Debug, Clone)]
203pub struct MemoryStore {
204 pub dir: PathBuf,
205 pub meta: MemoryMeta,
206 home: PathBuf,
207 home_directory: std::sync::Arc<crate::secure_fs::Directory>,
208}
209#[derive(Serialize, Deserialize)]
210#[serde(deny_unknown_fields)]
211struct MoveJournal {
212 source: String,
213 recovery: String,
214}
215impl MemoryStore {
216 pub fn open(home: &Path, id: &str, created_at: &str) -> Result<Self, MemoryError> {
217 let home = std::path::absolute(home)?;
218 let root = home.join("memory");
219 owned_directory(&home)?;
220 let home_directory = std::sync::Arc::new(crate::secure_fs::Directory::open(&home)?);
221 home_directory.ensure_dir(Path::new("memory"))?;
222 let dir = root.join(memory_slug(id, cfg!(windows))?);
223 let store = Self {
224 dir,
225 home,
226 home_directory,
227 meta: MemoryMeta {
228 schema_version: 1,
229 model_id: id.into(),
230 created_at: created_at.into(),
231 embedding: None,
232 embedding_unsupported: None,
233 },
234 };
235 store.initialize()
236 }
237 fn initialize(self) -> Result<Self, MemoryError> {
238 let mut store = self;
239 store.recover_if_needed()?;
240 store.mkdir(&store.dir)?;
241 let path = store.dir.join("meta.json");
242 if !path.try_exists()? {
243 store.meta.validate()?;
244 let mut bytes = serde_json::to_vec_pretty(&store.meta)?;
245 bytes.push(b'\n');
246 match store
247 .home_directory
248 .write(store.relative(&path)?, &bytes, true, false)
249 {
250 Ok(()) => (),
251 Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => (),
252 Err(error) => return Err(error.into()),
253 }
254 }
255 store.meta = store.read_meta()?;
256 Ok(store)
257 }
258 pub fn existing(home: &Path, id: &str) -> Result<Self, MemoryError> {
259 Self::existing_inner(home, id, true)
260 }
261 pub fn snapshot(home: &Path, id: &str) -> Result<SourceMemory, MemoryError> {
262 let store = Self::existing_inner(home, id, false)?;
263 load_files(&store.files()?, &store.read_meta()?)
264 }
265 fn existing_inner(home: &Path, id: &str, recover: bool) -> Result<Self, MemoryError> {
266 let home = std::path::absolute(home)?;
267 let dir = home.join("memory").join(memory_slug(id, cfg!(windows))?);
268 let mut store = Self {
269 dir,
270 home_directory: std::sync::Arc::new(crate::secure_fs::Directory::open(&home)?),
271 home,
272 meta: MemoryMeta {
273 schema_version: 1,
274 model_id: id.into(),
275 created_at: String::new(),
276 embedding: None,
277 embedding_unsupported: None,
278 },
279 };
280 if recover {
281 store.recover_if_needed()?;
282 } else if store.transaction_dir()?.try_exists()? {
283 return Err(MemoryError(
284 "memory recovery required before preview".into(),
285 ));
286 }
287 store.meta = store.read_meta()?;
288 Ok(store)
289 }
290 fn check_path(&self) -> Result<(), MemoryError> {
291 self.home_directory.check()?;
292 for path in [&self.home, &self.home.join("memory"), &self.dir] {
293 let metadata = fs::symlink_metadata(path)?;
294 if !metadata.is_dir() || metadata.file_type().is_symlink() {
295 return Err(MemoryError("unsafe memory directory".into()));
296 }
297 }
298 #[cfg(unix)]
299 {
300 use std::os::unix::fs::PermissionsExt;
301 if fs::metadata(&self.dir)?.permissions().mode() & 0o077 != 0 {
302 return Err(MemoryError("memory store permissions are too broad".into()));
303 }
304 }
305 if !self
306 .dir
307 .canonicalize()?
308 .starts_with(self.home.join("memory").canonicalize()?)
309 {
310 return Err(MemoryError("memory path escaped root".into()));
311 }
312 Ok(())
313 }
314 pub fn read_meta(&self) -> Result<MemoryMeta, MemoryError> {
315 self.check_path()?;
316 let raw = self.read_at(&self.dir.join("meta.json"), 16384, true)?;
317 let value: serde_json::Value = serde_json::from_str(&raw)?;
318 if value
319 .as_object()
320 .is_some_and(|object| object.values().any(serde_json::Value::is_null))
321 {
322 return Err(MemoryError("null metadata fields".into()));
323 }
324 let meta: MemoryMeta = serde_json::from_value(value)?;
325 meta.validate()?;
326 if meta.model_id != self.meta.model_id {
327 return Err(MemoryError("memory slug collision".into()));
328 }
329 Ok(meta)
330 }
331 pub fn lock(&self) -> Result<LockGuard, MemoryError> {
332 Ok(StateStore::new(Config::from_home(&self.home)?).lock(Duration::from_secs(10))?)
333 }
334 pub fn write_meta(&self, guard: &LockGuard, meta: &MemoryMeta) -> Result<(), MemoryError> {
335 guard.assert_for(&Config::from_home(&self.home)?.lock)?;
336 self.read_meta()?;
337 meta.validate()?;
338 if meta.model_id != self.meta.model_id {
339 return Err(MemoryError("metadata owner changed".into()));
340 }
341 let mut bytes = serde_json::to_vec_pretty(meta)?;
342 bytes.push(b'\n');
343 self.write_at(&self.dir.join("meta.json"), &bytes)
344 }
345 fn relative<'path>(&self, path: &'path Path) -> Result<&'path Path, MemoryError> {
346 path.strip_prefix(&self.home)
347 .map_err(|_| MemoryError("path escaped memory home".into()))
348 }
349 fn mkdir(&self, path: &Path) -> Result<(), MemoryError> {
350 Ok(self.home_directory.ensure_dir(self.relative(path)?)?)
351 }
352 fn write_at(&self, path: &Path, bytes: &[u8]) -> Result<(), MemoryError> {
353 Ok(self
354 .home_directory
355 .write(self.relative(path)?, bytes, false, false)?)
356 }
357 fn read_at(
358 &self,
359 path: &Path,
360 maximum: usize,
361 secret: bool,
362 ) -> Result<String, crate::state::StateError> {
363 let relative = path
364 .strip_prefix(&self.home)
365 .map_err(|_| crate::state::StateError {
366 kind: "invalid",
367 message: "path escaped memory home".into(),
368 })?;
369 let bytes = self
370 .home_directory
371 .read(relative, maximum as u64, secret)
372 .map_err(|error| crate::state::StateError {
373 kind: if error.kind() == std::io::ErrorKind::NotFound {
374 "absent"
375 } else {
376 "io"
377 },
378 message: error.to_string(),
379 })?;
380 String::from_utf8(bytes).map_err(|_| crate::state::StateError {
381 kind: "invalid",
382 message: "memory file is not UTF-8".into(),
383 })
384 }
385 fn rename_at(&self, from: impl AsRef<Path>, to: impl AsRef<Path>) -> Result<(), MemoryError> {
386 let directory = self.home_directory.dir()?;
387 directory.rename(
388 self.relative(from.as_ref())?,
389 directory,
390 self.relative(to.as_ref())?,
391 )?;
392 #[cfg(unix)]
393 directory.open(".")?.sync_all()?;
394 Ok(())
395 }
396 fn remove_dir_at(&self, path: impl AsRef<Path>) -> Result<(), MemoryError> {
397 Ok(self
398 .home_directory
399 .dir()?
400 .remove_dir_all(self.relative(path.as_ref())?)?)
401 }
402}
403
404#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
405#[serde(deny_unknown_fields)]
406pub struct Turn {
407 pub role: String,
408 pub content: String,
409 pub ts: String,
410}
411#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
412#[serde(deny_unknown_fields)]
413pub struct Chunk {
414 pub id: String,
415 pub text: String,
416 pub ts: String,
417}
418#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
419#[serde(deny_unknown_fields)]
420pub struct Vector {
421 pub id: String,
422 pub vector: Vec<f64>,
423}
424#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
425#[serde(deny_unknown_fields)]
426pub struct Fact {
427 pub text: String,
428 pub ts: String,
429}
430#[derive(Debug, Clone, Deserialize, Serialize)]
431#[serde(rename_all = "camelCase", deny_unknown_fields)]
432struct Facts {
433 schema_version: u8,
434 facts: Vec<Fact>,
435}
436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
437#[serde(rename_all = "camelCase", deny_unknown_fields)]
438pub struct SourceMemory {
439 pub turns: Vec<Turn>,
440 #[serde(skip_serializing_if = "Option::is_none")]
441 pub system_prompt: Option<String>,
442 pub facts_text: String,
443 pub facts_present: bool,
444 #[serde(skip_serializing_if = "Option::is_none")]
445 pub embedding: Option<SourceEmbedding>,
446}
447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
448#[serde(deny_unknown_fields)]
449pub struct SourceEmbedding {
450 pub meta: EmbeddingMeta,
451 pub chunks: Vec<Chunk>,
452 pub vectors: Vec<Vector>,
453}
454pub struct EmbeddingOutput {
455 pub vectors: Vec<Vec<f64>>,
456 pub dimension: usize,
457}
458#[async_trait::async_trait]
459pub trait Embedder: Send + Sync {
460 fn model(&self) -> &str;
461 async fn embed(
462 &self,
463 texts: &[String],
464 cancel: &tokio_util::sync::CancellationToken,
465 ) -> Result<EmbeddingOutput, MemoryError>;
466}
467pub struct CaptureOptions<'capture> {
468 pub timestamp: &'capture str,
469 pub embedder: Option<&'capture dyn Embedder>,
470 pub embedding_unsupported: bool,
471}
472#[derive(Debug, Serialize)]
473#[serde(rename_all = "camelCase")]
474pub struct CaptureResult {
475 pub turns_appended: usize,
476 pub facts_extracted: usize,
477 pub vectors_embedded: usize,
478 #[serde(skip_serializing_if = "Option::is_none")]
480 pub embedding_skipped: Option<String>,
481}
482type Files = std::collections::BTreeMap<String, String>;
483fn jsonl<T: serde::de::DeserializeOwned>(raw: &str) -> Result<Vec<T>, MemoryError> {
484 let mut records = Vec::new();
485 for line in raw.lines().filter(|line| !line.trim().is_empty()) {
486 records.push(serde_json::from_str(line)?);
487 if records.len() > 100000 {
488 return Err(MemoryError("record limit exceeded".into()));
489 }
490 }
491 Ok(records)
492}
493fn encode_lines<T: Serialize>(records: &[T]) -> Result<String, MemoryError> {
494 let mut result = String::new();
495 for record in records {
496 result.push_str(&serde_json::to_string(record)?);
497 result.push('\n');
498 }
499 Ok(result)
500}
501fn pretty<T: Serialize>(value: &T) -> Result<String, MemoryError> {
502 Ok(format!("{}\n", serde_json::to_string_pretty(value)?))
503}
504pub fn extract_facts(text: &str) -> Result<Vec<String>, MemoryError> {
505 let rules = [
506 (
507 r"(?i)(?-u:\b)(?:my name is|call me)\s+([^.,;!?\n]+)",
508 "name = ",
509 ),
510 (
511 r"(?i)(?-u:\b)i (?:live|reside) in\s+([^.,;!?\n]+)",
512 "location = ",
513 ),
514 (
515 r"(?i)(?-u:\b)i work (?:as|at)\s+([^.,;!?\n]+)",
516 "occupation = ",
517 ),
518 (
519 r"(?i)(?-u:\b)i (?:like|love|prefer|enjoy)\s+([^.,;!?\n]+)",
520 "preference = ",
521 ),
522 (r"(?i)(?-u:\b)remember(?: that)?[:\s]+([^.\n]+)", ""),
523 ];
524 let mut result = Vec::new();
525 let mut seen = std::collections::HashSet::new();
526 for (pattern, prefix) in rules {
527 let regex = regex::Regex::new(pattern).map_err(|error| MemoryError(error.to_string()))?;
528 for captures in regex.captures_iter(text) {
529 let Some(value) = captures
530 .get(1)
531 .map(|value| value.as_str().trim())
532 .filter(|value| !value.is_empty())
533 else {
534 continue;
535 };
536 let fact = format!("{prefix}{value}");
537 if seen.insert(fact.to_lowercase()) {
538 result.push(fact);
539 }
540 }
541 }
542 Ok(result)
543}
544fn validate_embeddings(output: &EmbeddingOutput, count: usize) -> Result<(), MemoryError> {
545 if output.dimension == 0
546 || output.dimension > 100000
547 || output.vectors.len() != count
548 || count
549 .checked_mul(output.dimension)
550 .is_none_or(|size| size > 2000000)
551 || output.vectors.iter().any(|vector| {
552 vector.len() != output.dimension || vector.iter().any(|value| !value.is_finite())
553 })
554 {
555 return Err(MemoryError("invalid embedding vectors or dimension".into()));
556 }
557 Ok(())
558}
559impl MemoryStore {
560 fn files(&self) -> Result<Files, MemoryError> {
561 self.read_meta()?;
562 let mut files = Files::new();
563 fn scan(
564 store: &MemoryStore,
565 directory: &cap_std::fs::Dir,
566 relative: &Path,
567 files: &mut Files,
568 total: &mut usize,
569 entries: &mut usize,
570 depth: usize,
571 ) -> Result<(), MemoryError> {
572 if depth > 40 {
573 return Err(MemoryError("memory directory depth exceeds limit".into()));
574 }
575 for entry in directory.entries()? {
576 let entry = entry?;
577 *entries += 1;
578 if *entries > 1024 {
579 return Err(MemoryError("memory file count exceeds limit".into()));
580 }
581 let kind = entry.file_type()?;
582 let child = relative.join(entry.file_name());
583 if kind.is_dir() {
584 scan(
585 store,
586 &directory.open_dir(entry.file_name())?,
587 &child,
588 files,
589 total,
590 entries,
591 depth + 1,
592 )?;
593 } else if kind.is_file() {
594 let relative = child
595 .to_str()
596 .ok_or_else(|| MemoryError("invalid memory filename encoding".into()))?
597 .replace('\\', "/");
598 let maximum = match relative.as_str() {
599 "meta.json" => 16384,
600 "facts.json" => 1048576,
601 "system.md" => 65536,
602 "embeddings/vectors.jsonl" => 16 * 1024 * 1024,
603 _ => 8 * 1024 * 1024,
604 };
605 let raw = store.read_at(&store.dir.join(&child), maximum, true)?;
606 *total += raw.len();
607 if *total > 64 * 1024 * 1024 {
608 return Err(MemoryError("memory store exceeds limit".into()));
609 }
610 files.insert(relative, raw);
611 } else {
612 return Err(MemoryError("symlink or special memory file".into()));
613 }
614 }
615 Ok(())
616 }
617 let directory = self.home_directory.subdir(self.relative(&self.dir)?)?;
618 scan(
619 self,
620 &directory,
621 Path::new(""),
622 &mut files,
623 &mut 0,
624 &mut 0,
625 0,
626 )?;
627 Ok(files)
628 }
629 pub fn load(&self) -> Result<SourceMemory, MemoryError> {
630 self.recover_if_needed()?;
631 let files = self.files()?;
632 load_files(&files, &self.read_meta()?)
633 }
634 fn transaction_dir(&self) -> Result<PathBuf, MemoryError> {
635 Ok(self.home.join(".staging").join(format!(
636 "memory-{}",
637 memory_slug(&self.meta.model_id, cfg!(windows))?
638 )))
639 }
640 pub fn recover(&self, guard: &LockGuard) -> Result<(), MemoryError> {
641 guard.assert_for(&Config::from_home(&self.home)?.lock)?;
642 let transaction = self.transaction_dir()?;
643 if !transaction.try_exists()? {
644 return Ok(());
645 }
646 self.home_directory.subdir(self.relative(&transaction)?)?;
647 let marker = match self.read_at(&transaction.join("phase"), 32, true) {
648 Ok(marker) => marker,
649 Err(error) if error.kind == "absent" => "staging".into(),
650 Err(error) => return Err(error.into()),
651 };
652 let previous = transaction.join("previous");
653 let next = transaction.join("next");
654 if marker.trim() == "moving" {
655 let target_id = self.read_at(&transaction.join("target"), 8192, true)?;
656 if memory_slug(&target_id, cfg!(windows))?
657 == memory_slug(&self.meta.model_id, cfg!(windows))?
658 {
659 return Err(MemoryError("recursive memory recovery".into()));
660 }
661 let target = Self {
662 home_directory: self.home_directory.clone(),
663 dir: self
664 .home
665 .join("memory")
666 .join(memory_slug(&target_id, cfg!(windows))?),
667 home: self.home.clone(),
668 meta: MemoryMeta {
669 model_id: target_id,
670 ..self.meta.clone()
671 },
672 };
673 if target.transaction_dir()?.try_exists()? {
674 let phase = self.read_at(&target.transaction_dir()?.join("phase"), 32, true)?;
675 if !["prepared", "committed"].contains(&phase.trim()) {
676 return Err(MemoryError("invalid move target journal".into()));
677 }
678 target.recover(guard)?;
679 }
680 if transaction.try_exists()? {
681 self.remove_dir_at(transaction)?;
682 }
683 return Ok(());
684 }
685 if marker.trim() == "staging" {
686 if previous.try_exists()? {
687 return Err(MemoryError("ambiguous staging journal".into()));
688 }
689 self.read_meta()?;
690 let quarantine = self
691 .home
692 .join(".staging")
693 .join(format!("memory-recovered-{}", uuid::Uuid::new_v4()));
694 self.rename_at(transaction, quarantine)?;
695 return Ok(());
696 }
697 if marker.trim() == "committed" {
698 self.read_meta()?;
699 self.recover_move(guard, false)?;
700 self.remove_dir_at(transaction)?;
701 return Ok(());
702 }
703 if marker.trim() != "prepared" {
704 return Err(MemoryError("invalid memory recovery journal".into()));
705 }
706 if previous.try_exists()? {
707 self.home_directory.subdir(self.relative(&previous)?)?;
708 if self.dir.try_exists()? {
709 self.check_path()?;
710 if next.try_exists()? {
711 return Err(MemoryError(
712 "ambiguous memory recovery; preserve all generations".into(),
713 ));
714 }
715 self.rename_at(&self.dir, &next)?;
716 }
717 self.rename_at(&previous, &self.dir)?;
718 }
719 self.read_meta()?;
720 self.recover_move(guard, true)?;
721 if next.try_exists()? {
722 let quarantine = self
723 .home
724 .join(".staging")
725 .join(format!("memory-recovered-{}", uuid::Uuid::new_v4()));
726 self.rename_at(&next, quarantine)?;
727 }
728 self.remove_dir_at(transaction)?;
729 Ok(())
730 }
731 fn recover_if_needed(&self) -> Result<(), MemoryError> {
732 if self.transaction_dir()?.try_exists()? {
733 let guard = self.lock()?;
734 self.recover(&guard)?;
735 guard.release()?;
736 }
737 Ok(())
738 }
739 fn publish(
740 &self,
741 guard: &LockGuard,
742 expected: &Files,
743 next: &Files,
744 ) -> Result<(), MemoryError> {
745 self.publish_pending(guard, expected, next)?;
746 self.commit_pending(guard)
747 }
748 fn publish_pending(
749 &self,
750 guard: &LockGuard,
751 expected: &Files,
752 next: &Files,
753 ) -> Result<(), MemoryError> {
754 guard.assert_for(&Config::from_home(&self.home)?.lock)?;
755 self.recover(guard)?;
756 if &self.files()? != expected {
757 return Err(MemoryError("memory changed during preparation".into()));
758 }
759 let transaction = self.transaction_dir()?;
760 self.mkdir(&self.home.join(".staging"))?;
761 if transaction.try_exists()? {
762 return Err(MemoryError("memory transaction already exists".into()));
763 }
764 self.mkdir(&transaction)?;
765 self.write_at(&transaction.join("phase"), b"staging\n")?;
766 let staged = transaction.join("next");
767 self.mkdir(&staged)?;
768 let staged_result = (|| {
769 for (name, raw) in next {
770 if !crate::acquire::safe_file(name) {
771 return Err(MemoryError("unsafe memory artifact name".into()));
772 }
773 let path = staged.join(name);
774 self.mkdir(
775 path.parent()
776 .ok_or_else(|| MemoryError("missing memory parent".into()))?,
777 )?;
778 self.write_at(&path, raw.as_bytes())?;
779 }
780 self.write_at(&transaction.join("phase"), b"prepared\n")?;
781 Ok::<_, MemoryError>(())
782 })();
783 if let Err(error) = staged_result {
784 self.remove_dir_at(&transaction)?;
785 return Err(error);
786 }
787 let commit = (|| {
788 guard.assert_owned()?;
789 if &self.files()? != expected {
790 return Err(MemoryError("memory changed before publication".into()));
791 }
792 self.rename_at(&self.dir, transaction.join("previous"))?;
793 self.rename_at(&staged, &self.dir)?;
794 if self.files()? != *next {
795 return Err(MemoryError("published memory verification failed".into()));
796 }
797 Ok::<_, MemoryError>(())
798 })();
799 if let Err(error) = commit {
800 self.recover(guard)?;
801 return Err(error);
802 }
803 Ok(())
804 }
805 fn commit_pending(&self, guard: &LockGuard) -> Result<(), MemoryError> {
806 guard.assert_for(&Config::from_home(&self.home)?.lock)?;
807 self.write_at(&self.transaction_dir()?.join("phase"), b"committed\n")?;
808 self.recover(guard)
809 }
810 fn prepare_move(&self, source: &MemoryStore, guard: &LockGuard) -> Result<(), MemoryError> {
811 guard.assert_for(&Config::from_home(&self.home)?.lock)?;
812 if source.home != self.home {
813 return Err(MemoryError("move crosses memory homes".into()));
814 }
815 source.check_path()?;
816 let recovery = format!("memory-moved-{}", uuid::Uuid::new_v4());
817 self.write_at(
818 &self.transaction_dir()?.join("move.json"),
819 &serde_json::to_vec(&MoveJournal {
820 source: source.meta.model_id.clone(),
821 recovery: recovery.clone(),
822 })?,
823 )?;
824 let source_transaction = source.transaction_dir()?;
825 if source_transaction.try_exists()? {
826 return Err(MemoryError("source transaction exists".into()));
827 }
828 self.mkdir(&source_transaction)?;
829 self.write_at(
830 &source_transaction.join("target"),
831 self.meta.model_id.as_bytes(),
832 )?;
833 self.write_at(&source_transaction.join("phase"), b"moving\n")?;
834 self.rename_at(&source.dir, self.home.join(".staging").join(recovery))?;
835 Ok(())
836 }
837 fn recover_move(&self, guard: &LockGuard, rollback: bool) -> Result<(), MemoryError> {
838 guard.assert_for(&Config::from_home(&self.home)?.lock)?;
839 let raw = match self.read_at(&self.transaction_dir()?.join("move.json"), 16384, true) {
840 Ok(raw) => raw,
841 Err(error) if error.kind == "absent" => return Ok(()),
842 Err(error) => return Err(error.into()),
843 };
844 let journal: MoveJournal = serde_json::from_str(&raw)?;
845 let suffix = journal
846 .recovery
847 .strip_prefix("memory-moved-")
848 .ok_or_else(|| MemoryError("invalid move recovery name".into()))?;
849 if uuid::Uuid::parse_str(suffix).is_err() {
850 return Err(MemoryError("invalid move recovery id".into()));
851 }
852 let slug = memory_slug(&journal.source, cfg!(windows))?;
853 if slug == memory_slug(&self.meta.model_id, cfg!(windows))? {
854 return Err(MemoryError("invalid move source".into()));
855 }
856 let source = self.home.join("memory").join(&slug);
857 let recovery = self.home.join(".staging").join(&journal.recovery);
858 if rollback && recovery.try_exists()? {
859 self.home_directory.subdir(self.relative(&recovery)?)?;
860 let meta: MemoryMeta =
861 serde_json::from_str(&self.read_at(&recovery.join("meta.json"), 16384, true)?)?;
862 meta.validate()?;
863 if meta.model_id != journal.source || source.try_exists()? {
864 return Err(MemoryError(
865 "ambiguous source recovery; bytes retained".into(),
866 ));
867 }
868 self.rename_at(recovery, source)?;
869 }
870 let source_transaction = self.home.join(".staging").join(format!("memory-{slug}"));
871 if source_transaction.try_exists()? {
872 self.home_directory
873 .subdir(self.relative(&source_transaction)?)?;
874 let target = self.read_at(&source_transaction.join("target"), 8192, true)?;
875 if target != self.meta.model_id {
876 return Err(MemoryError("move recovery target changed".into()));
877 }
878 self.remove_dir_at(source_transaction)?;
879 }
880 Ok(())
881 }
882 pub async fn capture(
883 &self,
884 user: &str,
885 assistant: &str,
886 options: CaptureOptions<'_>,
887 cancel: &tokio_util::sync::CancellationToken,
888 ) -> Result<CaptureResult, MemoryError> {
889 if user.len() + assistant.len() > 8 * 1024 * 1024
890 || options.timestamp.is_empty()
891 || options.timestamp.len() > 1024
892 {
893 return Err(MemoryError("invalid capture input".into()));
894 }
895 if cancel.is_cancelled() {
896 return Err(MemoryError("cancelled".into()));
897 }
898 self.recover_if_needed()?;
899 let expected = self.files()?;
900 let mut source = load_files(&expected, &self.read_meta()?)?;
901 let mut meta = self.read_meta()?;
902 let texts = [
903 rigspark_core::reports::strip_control(user),
904 rigspark_core::reports::strip_control(assistant),
905 ];
906 let chunks: Vec<_> = texts
907 .iter()
908 .filter(|text| !text.is_empty())
909 .cloned()
910 .collect();
911 let mut embedding_skipped = None;
912 let embedding = if !options.embedding_unsupported && !chunks.is_empty() {
913 if let Some(embedder) = options.embedder {
914 let attempt = tokio::select! {biased;_=cancel.cancelled()=>return Err(MemoryError("cancelled".into())),result=tokio::time::timeout(Duration::from_secs(120),embedder.embed(&chunks,cancel))=>result};
915 match attempt
919 .map_err(|_| MemoryError("embedding timed out".into()))
920 .and_then(|result| result)
921 {
922 Err(error) => {
923 embedding_skipped = Some(format!(
924 "{} ({})",
925 error.0,
926 rigspark_core::reports::strip_control(embedder.model())
927 ));
928 None
929 }
930 Ok(result) => {
931 validate_embeddings(&result, chunks.len())?;
932 let space = EmbeddingMeta {
933 model: embedder.model().into(),
934 dimension: result.dimension,
935 };
936 if space.model.is_empty()
937 || meta
938 .embedding
939 .as_ref()
940 .is_some_and(|existing| existing != &space)
941 {
942 return Err(MemoryError("embedding space mismatch".into()));
943 }
944 Some((space, result))
945 }
946 }
947 } else {
948 None
949 }
950 } else {
951 None
952 };
953 let before = source.turns.len();
954 for (role, content) in ["user", "assistant"].into_iter().zip(&texts) {
955 if !content.is_empty() {
956 source.turns.push(Turn {
957 role: role.into(),
958 content: content.clone(),
959 ts: options.timestamp.into(),
960 });
961 }
962 }
963 let mut facts = if source.facts_present {
964 serde_json::from_str::<Facts>(&source.facts_text)?
965 } else {
966 Facts {
967 schema_version: 1,
968 facts: Vec::new(),
969 }
970 };
971 validate_facts(&facts)?;
972 let mut known: std::collections::HashSet<_> = facts
973 .facts
974 .iter()
975 .map(|fact| fact.text.to_lowercase())
976 .collect();
977 let mut added = 0;
978 for text in extract_facts(&texts[0])? {
979 if known.insert(text.to_lowercase()) {
980 facts.facts.push(Fact {
981 text,
982 ts: options.timestamp.into(),
983 });
984 added += 1;
985 }
986 }
987 let mut next = expected.clone();
988 next.insert("conversation.jsonl".into(), encode_lines(&source.turns)?);
989 if added > 0 || !source.facts_present {
990 next.insert("facts.json".into(), pretty(&facts)?);
991 }
992 let mut embedded = 0;
993 if options.embedding_unsupported {
994 meta.embedding = None;
995 meta.embedding_unsupported = Some(true);
996 } else if let Some((space, output)) = embedding {
997 let mut index = source.embedding.unwrap_or(SourceEmbedding {
998 meta: space.clone(),
999 chunks: Vec::new(),
1000 vectors: Vec::new(),
1001 });
1002 for (text, vector) in chunks.into_iter().zip(output.vectors) {
1003 let id = uuid::Uuid::new_v4().to_string();
1004 index.chunks.push(Chunk {
1005 id: id.clone(),
1006 text,
1007 ts: options.timestamp.into(),
1008 });
1009 index.vectors.push(Vector { id, vector });
1010 embedded += 1;
1011 }
1012 meta.embedding = Some(space);
1013 meta.embedding_unsupported = None;
1014 next.insert(
1015 "embeddings/chunks.jsonl".into(),
1016 encode_lines(&index.chunks)?,
1017 );
1018 next.insert(
1019 "embeddings/vectors.jsonl".into(),
1020 encode_lines(&index.vectors)?,
1021 );
1022 }
1023 meta.validate()?;
1024 next.insert("meta.json".into(), pretty(&meta)?);
1025 load_files(&next, &meta)?;
1026 let guard = self.lock()?;
1027 if cancel.is_cancelled() {
1028 return Err(MemoryError("cancelled".into()));
1029 }
1030 self.publish(&guard, &expected, &next)?;
1031 guard.release()?;
1032 Ok(CaptureResult {
1033 turns_appended: source.turns.len() - before,
1034 facts_extracted: added,
1035 vectors_embedded: embedded,
1036 embedding_skipped,
1037 })
1038 }
1039}
1040fn validate_facts(facts: &Facts) -> Result<(), MemoryError> {
1041 if facts.schema_version != 1
1042 || facts.facts.len() > 100000
1043 || facts
1044 .facts
1045 .iter()
1046 .any(|fact| fact.text.is_empty() || fact.ts.is_empty())
1047 {
1048 return Err(MemoryError("invalid facts".into()));
1049 }
1050 Ok(())
1051}
1052fn load_files(files: &Files, meta: &MemoryMeta) -> Result<SourceMemory, MemoryError> {
1053 let turns: Vec<Turn> = jsonl(
1054 files
1055 .get("conversation.jsonl")
1056 .map(String::as_str)
1057 .unwrap_or(""),
1058 )?;
1059 if turns
1060 .iter()
1061 .any(|turn| !["user", "assistant", "system"].contains(&turn.role.as_str()))
1062 {
1063 return Err(MemoryError("invalid stored role".into()));
1064 }
1065 let embedding = if let Some(space) = &meta.embedding {
1066 let chunks: Vec<Chunk> = jsonl(
1067 files
1068 .get("embeddings/chunks.jsonl")
1069 .map(String::as_str)
1070 .unwrap_or(""),
1071 )?;
1072 let vectors: Vec<Vector> = jsonl(
1073 files
1074 .get("embeddings/vectors.jsonl")
1075 .map(String::as_str)
1076 .unwrap_or(""),
1077 )?;
1078 let ids: std::collections::HashSet<_> = chunks.iter().map(|chunk| &chunk.id).collect();
1079 let vector_ids: std::collections::HashSet<_> =
1080 vectors.iter().map(|vector| &vector.id).collect();
1081 if ids.len() != chunks.len()
1082 || vector_ids.len() != vectors.len()
1083 || ids != vector_ids
1084 || vectors.iter().any(|vector| {
1085 vector.vector.len() != space.dimension
1086 || vector.vector.iter().any(|value| !value.is_finite())
1087 })
1088 {
1089 return Err(MemoryError("inconsistent embedding index".into()));
1090 }
1091 Some(SourceEmbedding {
1092 meta: space.clone(),
1093 chunks,
1094 vectors,
1095 })
1096 } else {
1097 None
1098 };
1099 let facts_text = files.get("facts.json").cloned().unwrap_or_default();
1100 let facts_present = files.contains_key("facts.json");
1101 Ok(SourceMemory {
1102 turns,
1103 embedding,
1104 system_prompt: files.get("system.md").cloned(),
1105 facts_text,
1106 facts_present,
1107 })
1108}
1109
1110#[async_trait::async_trait]
1111pub trait Summarizer: Send + Sync {
1112 async fn summarize(
1113 &self,
1114 turns: &[Turn],
1115 cancel: &tokio_util::sync::CancellationToken,
1116 ) -> Result<String, MemoryError>;
1117}
1118pub struct MigrationOptions<'migration> {
1119 pub context: u32,
1120 pub embedder: Option<&'migration dyn Embedder>,
1121 pub target_dimension: Option<usize>,
1122 pub summarizer: Option<&'migration dyn Summarizer>,
1123 pub embedding_unsupported: bool,
1124}
1125#[derive(Debug, Clone, Serialize)]
1126#[serde(rename_all = "camelCase")]
1127pub struct MigrationSummary {
1128 pub turns_carried: usize,
1129 pub turns_summarized: usize,
1130 pub vectors_reembedded: usize,
1131 pub strategy: String,
1132 pub embedding_strategy: String,
1133}
1134pub struct MigrationPlan {
1135 pub source: SourceMemory,
1136 pub embedding_unsupported: bool,
1137 pub summary: MigrationSummary,
1138}
1139fn token_count(text: &str) -> usize {
1140 text.encode_utf16().count().div_ceil(4)
1141}
1142fn truncate_utf16(text: &str, maximum: usize) -> String {
1143 let mut length = 0;
1144 text.chars()
1145 .take_while(|character| {
1146 length += character.len_utf16();
1147 length <= maximum
1148 })
1149 .collect()
1150}
1151pub async fn plan_migration(
1152 source: &SourceMemory,
1153 options: MigrationOptions<'_>,
1154 cancel: &tokio_util::sync::CancellationToken,
1155) -> Result<MigrationPlan, MemoryError> {
1156 if options.context == 0 || options.context > 10000000 || source.turns.len() > 100000 {
1157 return Err(MemoryError("invalid migration budget or history".into()));
1158 }
1159 if cancel.is_cancelled() {
1160 return Err(MemoryError("cancelled".into()));
1161 }
1162 let mut output = source.clone();
1163 let mut summary = MigrationSummary {
1164 turns_carried: source.turns.len(),
1165 turns_summarized: 0,
1166 vectors_reembedded: 0,
1167 strategy: "none".into(),
1168 embedding_strategy: "none".into(),
1169 };
1170 let reserved = token_count(source.system_prompt.as_deref().unwrap_or(""))
1171 + token_count(&source.facts_text);
1172 let turn_cost = source
1173 .turns
1174 .iter()
1175 .map(|turn| token_count(&turn.content))
1176 .sum::<usize>();
1177 if reserved + turn_cost > options.context as usize {
1178 let available = (options.context as usize).saturating_sub(reserved + 256);
1179 let mut running = 0;
1180 let mut kept = 0;
1181 for turn in source.turns.iter().rev() {
1182 let cost = token_count(&turn.content);
1183 if running + cost > available {
1184 break;
1185 }
1186 running += cost;
1187 kept += 1;
1188 }
1189 let overflow = source.turns.len() - kept;
1190 if overflow > 0 {
1191 let content = if let Some(summarizer) = options.summarizer {
1192 let text = tokio::select! {biased;_=cancel.cancelled()=>return Err(MemoryError("cancelled".into())),result=tokio::time::timeout(Duration::from_secs(120),summarizer.summarize(&source.turns[..overflow],cancel))=>result.map_err(|_|MemoryError("summarization timed out".into()))??};
1193 summary.strategy = "summarize".into();
1194 truncate_utf16(
1195 &format!(
1196 "Summary of prior conversation: {}",
1197 rigspark_core::reports::strip_control(&text)
1198 ),
1199 1024,
1200 )
1201 } else {
1202 summary.strategy = "truncate".into();
1203 format!("[{overflow} earlier turns omitted during migration]")
1204 };
1205 output.turns = vec![Turn {
1206 role: "system".into(),
1207 content,
1208 ts: source.turns[0].ts.clone(),
1209 }];
1210 output.turns.extend_from_slice(&source.turns[overflow..]);
1211 summary.turns_carried = kept;
1212 summary.turns_summarized = overflow;
1213 }
1214 }
1215 if options.embedding_unsupported {
1216 output.embedding = None;
1217 } else if let Some(index) = &source.embedding {
1218 if !index.chunks.is_empty() {
1219 if let Some(embedder) = options.embedder.filter(|embedder| {
1220 embedder.model() != index.meta.model
1221 || options.target_dimension != Some(index.meta.dimension)
1222 }) {
1223 let dimension = options
1224 .target_dimension
1225 .filter(|dimension| *dimension > 0 && *dimension <= 100000)
1226 .ok_or_else(|| MemoryError("target embedding dimension required".into()))?;
1227 let texts: Vec<_> = index
1228 .chunks
1229 .iter()
1230 .map(|chunk| chunk.text.clone())
1231 .collect();
1232 let output_vectors = tokio::select! {biased;_=cancel.cancelled()=>return Err(MemoryError("cancelled".into())),result=tokio::time::timeout(Duration::from_secs(120),embedder.embed(&texts,cancel))=>result.map_err(|_|MemoryError("reembedding timed out".into()))??};
1233 validate_embeddings(&output_vectors, texts.len())?;
1234 if output_vectors.dimension != dimension {
1235 return Err(MemoryError("reembedding dimension mismatch".into()));
1236 }
1237 let vectors = index
1238 .chunks
1239 .iter()
1240 .zip(output_vectors.vectors)
1241 .map(|(chunk, vector)| Vector {
1242 id: chunk.id.clone(),
1243 vector,
1244 })
1245 .collect();
1246 output.embedding = Some(SourceEmbedding {
1247 meta: EmbeddingMeta {
1248 model: embedder.model().into(),
1249 dimension,
1250 },
1251 chunks: index.chunks.clone(),
1252 vectors,
1253 });
1254 summary.embedding_strategy = "reembed".into();
1255 summary.vectors_reembedded = texts.len();
1256 } else {
1257 summary.embedding_strategy = "reuse".into();
1258 }
1259 } else {
1260 output.embedding = None;
1261 }
1262 }
1263 Ok(MigrationPlan {
1264 source: output,
1265 embedding_unsupported: options.embedding_unsupported,
1266 summary,
1267 })
1268}
1269pub struct PreparedMigration {
1270 source_dir: PathBuf,
1271 source_id: String,
1272 source_files: Files,
1273 target_id: String,
1274 prior_target: Option<Files>,
1275 plan: MigrationPlan,
1276}
1277impl PreparedMigration {
1278 pub fn summary(&self) -> &MigrationSummary {
1279 &self.plan.summary
1280 }
1281}
1282impl MemoryStore {
1283 pub async fn migrate(
1284 &self,
1285 target_id: &str,
1286 created_at: &str,
1287 options: MigrationOptions<'_>,
1288 move_source: bool,
1289 cancel: &tokio_util::sync::CancellationToken,
1290 ) -> Result<MemoryStore, MemoryError> {
1291 let prepared = self.prepare_migration(target_id, options, cancel).await?;
1292 self.commit_migration(prepared, created_at, move_source, cancel)
1293 }
1294 pub async fn prepare_migration(
1295 &self,
1296 target_id: &str,
1297 options: MigrationOptions<'_>,
1298 cancel: &tokio_util::sync::CancellationToken,
1299 ) -> Result<PreparedMigration, MemoryError> {
1300 if memory_slug(target_id, cfg!(windows))?
1301 == memory_slug(&self.meta.model_id, cfg!(windows))?
1302 {
1303 return Err(MemoryError("source and target stores must differ".into()));
1304 }
1305 self.recover_if_needed()?;
1306 let source_files = self.files()?;
1307 let source = load_files(&source_files, &self.read_meta()?)?;
1308 let target_path = self
1309 .home
1310 .join("memory")
1311 .join(memory_slug(target_id, cfg!(windows))?);
1312 let target_probe = Self {
1313 home_directory: self.home_directory.clone(),
1314 dir: target_path.clone(),
1315 home: self.home.clone(),
1316 meta: MemoryMeta {
1317 model_id: target_id.into(),
1318 ..self.meta.clone()
1319 },
1320 };
1321 target_probe.recover_if_needed()?;
1322 let prior_target = if target_path.try_exists()? {
1323 Some(Self::existing(&self.home, target_id)?.files()?)
1324 } else {
1325 None
1326 };
1327 let plan = plan_migration(&source, options, cancel).await?;
1328 Ok(PreparedMigration {
1329 source_dir: self.dir.clone(),
1330 source_id: self.meta.model_id.clone(),
1331 source_files,
1332 target_id: target_id.into(),
1333 prior_target,
1334 plan,
1335 })
1336 }
1337 pub fn commit_migration(
1338 &self,
1339 prepared: PreparedMigration,
1340 created_at: &str,
1341 move_source: bool,
1342 cancel: &tokio_util::sync::CancellationToken,
1343 ) -> Result<MemoryStore, MemoryError> {
1344 self.commit_migration_with(prepared, created_at, move_source, cancel, || Ok(()))
1345 }
1346 pub fn commit_migration_with(
1347 &self,
1348 prepared: PreparedMigration,
1349 created_at: &str,
1350 move_source: bool,
1351 cancel: &tokio_util::sync::CancellationToken,
1352 check: impl FnOnce() -> Result<(), MemoryError>,
1353 ) -> Result<MemoryStore, MemoryError> {
1354 if prepared.source_dir != self.dir || prepared.source_id != self.meta.model_id {
1355 return Err(MemoryError(
1356 "prepared migration belongs to another source".into(),
1357 ));
1358 }
1359 let PreparedMigration {
1360 source_files,
1361 target_id,
1362 prior_target,
1363 plan,
1364 ..
1365 } = prepared;
1366 let target_id = target_id.as_str();
1367 let target_path = self
1368 .home
1369 .join("memory")
1370 .join(memory_slug(target_id, cfg!(windows))?);
1371 let target_probe = Self {
1372 dir: target_path.clone(),
1373 home: self.home.clone(),
1374 home_directory: self.home_directory.clone(),
1375 meta: MemoryMeta {
1376 model_id: target_id.into(),
1377 ..self.meta.clone()
1378 },
1379 };
1380 let guard = self.lock()?;
1381 check()?;
1382 if cancel.is_cancelled() {
1383 return Err(MemoryError("cancelled".into()));
1384 }
1385 if self.files()? != source_files {
1386 return Err(MemoryError(
1387 "source memory changed during preparation".into(),
1388 ));
1389 }
1390 if target_probe.transaction_dir()?.try_exists()? {
1391 return Err(MemoryError(
1392 "target transaction changed during preparation".into(),
1393 ));
1394 }
1395 let current_target = if target_path.try_exists()? {
1396 Some(Self::existing(&self.home, target_id)?.files()?)
1397 } else {
1398 None
1399 };
1400 if current_target != prior_target {
1401 return Err(MemoryError(
1402 "target memory changed during preparation".into(),
1403 ));
1404 }
1405 let mut target = target_probe;
1406 target.meta.created_at = created_at.into();
1407 target.meta.embedding = None;
1408 target.meta.embedding_unsupported = None;
1409 let target = target.initialize()?;
1410 let expected = target.files()?;
1411 let mut meta = target.read_meta()?;
1412 meta.embedding = plan
1413 .source
1414 .embedding
1415 .as_ref()
1416 .map(|index| index.meta.clone());
1417 meta.embedding_unsupported = plan.embedding_unsupported.then_some(true);
1418 let mut next = source_files.clone();
1419 next.insert("meta.json".into(), pretty(&meta)?);
1420 next.insert(
1421 "conversation.jsonl".into(),
1422 encode_lines(&plan.source.turns)?,
1423 );
1424 if let Some(persona) = &plan.source.system_prompt {
1425 next.insert("system.md".into(), persona.clone());
1426 } else {
1427 next.remove("system.md");
1428 }
1429 if plan.source.facts_present {
1430 next.insert("facts.json".into(), plan.source.facts_text.clone());
1431 } else {
1432 next.remove("facts.json");
1433 }
1434 if let Some(index) = &plan.source.embedding {
1435 next.insert(
1436 "embeddings/chunks.jsonl".into(),
1437 encode_lines(&index.chunks)?,
1438 );
1439 next.insert(
1440 "embeddings/vectors.jsonl".into(),
1441 encode_lines(&index.vectors)?,
1442 );
1443 } else {
1444 next.remove("embeddings/chunks.jsonl");
1445 next.remove("embeddings/vectors.jsonl");
1446 }
1447 load_files(&next, &meta)?;
1448 if let Err(error) = target.publish_pending(&guard, &expected, &next) {
1449 if prior_target.is_none() && target.dir.try_exists()? && target.files()? == expected {
1450 self.remove_dir_at(&target.dir)?;
1451 }
1452 return Err(error);
1453 }
1454 let finish = (|| {
1455 if move_source {
1456 if self.files()? != source_files {
1457 return Err(MemoryError("source changed before retirement".into()));
1458 }
1459 target.prepare_move(self, &guard)?;
1460 }
1461 target.commit_pending(&guard)
1462 })();
1463 if let Err(error) = finish {
1464 target.recover(&guard)?;
1465 if prior_target.is_none() && target.files()? == expected {
1466 self.remove_dir_at(&target.dir)?;
1467 }
1468 return Err(error);
1469 }
1470 guard.release()?;
1471 Self::existing(&self.home, target_id)
1472 }
1473}
1474
1475#[cfg(test)]
1476mod boundary_tests {
1477 use super::*;
1478 use tokio_util::sync::CancellationToken;
1479
1480 fn meta() -> MemoryMeta {
1481 MemoryMeta {
1482 schema_version: 1,
1483 model_id: "qwen3:8b".into(),
1484 created_at: "2026-11-06T00:00:00Z".into(),
1485 embedding: Some(EmbeddingMeta {
1486 model: "nomic-embed-text".into(),
1487 dimension: 4,
1488 }),
1489 embedding_unsupported: None,
1490 }
1491 }
1492 fn turn(content: &str) -> Turn {
1493 Turn {
1494 role: "user".into(),
1495 content: content.into(),
1496 ts: "t".into(),
1497 }
1498 }
1499 fn source(turns: Vec<Turn>, system: Option<&str>) -> SourceMemory {
1500 SourceMemory {
1501 turns,
1502 system_prompt: system.map(Into::into),
1503 facts_text: String::new(),
1504 facts_present: false,
1505 embedding: None,
1506 }
1507 }
1508 fn budget(context: u32) -> MigrationOptions<'static> {
1509 MigrationOptions {
1510 context,
1511 embedder: None,
1512 target_dimension: None,
1513 summarizer: None,
1514 embedding_unsupported: false,
1515 }
1516 }
1517 struct Fixed(&'static str, usize);
1518 #[async_trait::async_trait]
1519 impl Embedder for Fixed {
1520 fn model(&self) -> &str {
1521 self.0
1522 }
1523 async fn embed(
1524 &self,
1525 texts: &[String],
1526 _: &CancellationToken,
1527 ) -> Result<EmbeddingOutput, MemoryError> {
1528 Ok(EmbeddingOutput {
1529 vectors: texts.iter().map(|_| vec![0.5; self.1]).collect(),
1530 dimension: self.1,
1531 })
1532 }
1533 }
1534
1535 #[test]
1536 fn metadata_limits_are_inclusive() {
1537 assert!(meta().validate().is_ok());
1538 let accepted: [fn(&mut MemoryMeta); 4] = [
1539 |meta| meta.model_id = "m".repeat(8192),
1540 |meta| meta.created_at = "c".repeat(1024),
1541 |meta| meta.embedding.as_mut().unwrap().model = "e".repeat(8192),
1542 |meta| meta.embedding.as_mut().unwrap().dimension = 100_000,
1543 ];
1544 for change in accepted {
1545 let mut edited = meta();
1546 change(&mut edited);
1547 assert!(edited.validate().is_ok(), "{edited:?}");
1548 }
1549 let mut unsupported = meta();
1550 unsupported.embedding = None;
1551 unsupported.embedding_unsupported = Some(true);
1552 assert!(unsupported.validate().is_ok());
1553 let rejected: [fn(&mut MemoryMeta); 10] = [
1554 |meta| meta.schema_version = 2,
1555 |meta| meta.model_id.clear(),
1556 |meta| meta.model_id = "m".repeat(8193),
1557 |meta| meta.created_at.clear(),
1558 |meta| meta.created_at = "c".repeat(1025),
1559 |meta| meta.embedding_unsupported = Some(false),
1560 |meta| meta.embedding.as_mut().unwrap().model.clear(),
1561 |meta| meta.embedding.as_mut().unwrap().model = "e".repeat(8193),
1562 |meta| meta.embedding.as_mut().unwrap().dimension = 0,
1563 |meta| meta.embedding.as_mut().unwrap().dimension = 100_001,
1564 ];
1565 for change in rejected {
1566 let mut edited = meta();
1567 change(&mut edited);
1568 assert!(edited.validate().is_err(), "{edited:?}");
1569 }
1570 }
1571
1572 #[test]
1573 fn slugs_reserve_windows_device_names_and_hash_only_past_128_bytes() {
1574 assert_eq!(memory_slug("con", false).unwrap(), "con");
1575 for (id, slug) in [
1576 ("con", "x-con"),
1577 ("COM1", "x-com1"),
1578 ("lpt9.gguf", "x-lpt9.gguf"),
1579 ("com0", "com0"),
1580 ("compute", "compute"),
1581 ("lpt10", "lpt10"),
1582 ] {
1583 assert_eq!(memory_slug(id, true).unwrap(), slug, "{id}");
1584 }
1585 let exact = "a".repeat(128);
1586 assert_eq!(memory_slug(&exact, false).unwrap(), exact);
1587 let long = memory_slug(&"a".repeat(129), false).unwrap();
1588 assert_eq!(long.len(), 128);
1589 assert!(long.starts_with(&"a".repeat(111)));
1590 assert!(memory_slug(&"a".repeat(1024 * 1024), false).is_ok());
1591 assert!(memory_slug(&"a".repeat(1024 * 1024 + 1), false).is_err());
1592 }
1593
1594 #[test]
1595 fn jsonl_allows_exactly_one_hundred_thousand_records() {
1596 let lines = "1\n".repeat(100_000);
1597 assert_eq!(jsonl::<u8>(&lines).unwrap().len(), 100_000);
1598 assert!(jsonl::<u8>(&format!("{lines}1\n")).is_err());
1599 }
1600
1601 #[test]
1602 fn embedding_output_must_match_count_dimension_and_size_caps() {
1603 let output = |count: usize, dimension: usize| EmbeddingOutput {
1604 vectors: vec![vec![0.25; dimension]; count],
1605 dimension,
1606 };
1607 assert!(validate_embeddings(&output(2, 4), 2).is_ok());
1608 assert!(validate_embeddings(&output(1, 100_000), 1).is_ok());
1609 assert!(validate_embeddings(&output(1000, 2000), 1000).is_ok());
1610 assert!(validate_embeddings(&output(1, 0), 1).is_err());
1611 assert!(validate_embeddings(&output(1, 100_001), 1).is_err());
1612 assert!(validate_embeddings(&output(2, 4), 3).is_err());
1613 assert!(validate_embeddings(&output(1001, 2000), 1001).is_err());
1614 let mut short = output(2, 4);
1615 short.vectors[1].pop();
1616 assert!(validate_embeddings(&short, 2).is_err());
1617 let mut infinite = output(2, 4);
1618 infinite.vectors[0][0] = f64::NAN;
1619 assert!(validate_embeddings(&infinite, 2).is_err());
1620 }
1621
1622 #[test]
1623 fn facts_need_schema_one_text_and_timestamp_within_count() {
1624 let fact = || Fact {
1625 text: "name = Ada".into(),
1626 ts: "t".into(),
1627 };
1628 let facts = |schema_version, facts| Facts {
1629 schema_version,
1630 facts,
1631 };
1632 assert!(validate_facts(&facts(1, vec![fact(); 100_000])).is_ok());
1633 assert!(validate_facts(&facts(1, vec![fact(); 100_001])).is_err());
1634 assert!(validate_facts(&facts(2, vec![fact()])).is_err());
1635 let mut blank = fact();
1636 blank.text.clear();
1637 assert!(validate_facts(&facts(1, vec![blank])).is_err());
1638 let mut undated = fact();
1639 undated.ts.clear();
1640 assert!(validate_facts(&facts(1, vec![undated])).is_err());
1641 }
1642
1643 #[test]
1644 fn embedding_index_must_pair_unique_ids_with_finite_vectors() {
1645 let chunk = |id: &str| format!(r#"{{"id":"{id}","text":"x","ts":"t"}}"#);
1646 let vector = |id: &str, values: &str| format!(r#"{{"id":"{id}","vector":[{values}]}}"#);
1647 let index = |chunks: &[String], vectors: &[String]| {
1648 let mut files = Files::new();
1649 files.insert("embeddings/chunks.jsonl".into(), chunks.join("\n"));
1650 files.insert("embeddings/vectors.jsonl".into(), vectors.join("\n"));
1651 load_files(&files, &meta())
1652 };
1653 let four = "1,2,3,4";
1654 assert!(
1655 index(
1656 &[chunk("a"), chunk("b")],
1657 &[vector("a", four), vector("b", four)]
1658 )
1659 .is_ok()
1660 );
1661 for (chunks, vectors) in [
1662 (vec![chunk("a"), chunk("a")], vec![vector("a", four)]),
1663 (vec![chunk("a")], vec![vector("a", four), vector("a", four)]),
1664 (vec![chunk("a")], vec![vector("b", four)]),
1665 (vec![chunk("a")], vec![vector("a", "1,2,3")]),
1666 (vec![chunk("a")], vec![vector("a", "1,2,3,1e999")]),
1667 ] {
1668 assert!(index(&chunks, &vectors).is_err(), "{chunks:?} {vectors:?}");
1669 }
1670 }
1671
1672 #[tokio::test]
1673 async fn migration_budget_bounds_and_exact_truncation() {
1674 let cancel = CancellationToken::new();
1675 let empty = source(Vec::new(), None);
1676 assert!(plan_migration(&empty, budget(0), &cancel).await.is_err());
1677 assert!(
1678 plan_migration(&empty, budget(10_000_000), &cancel)
1679 .await
1680 .is_ok()
1681 );
1682 assert!(
1683 plan_migration(&empty, budget(10_000_001), &cancel)
1684 .await
1685 .is_err()
1686 );
1687 let crowded = source(vec![turn("x"); 100_001], None);
1688 assert!(
1689 plan_migration(&crowded, budget(10_000_000), &cancel)
1690 .await
1691 .is_err()
1692 );
1693 let full = source(vec![turn("x"); 100_000], None);
1694 assert!(
1695 plan_migration(&full, budget(10_000_000), &cancel)
1696 .await
1697 .is_ok()
1698 );
1699 let mut factual = source(vec![turn(&"x".repeat(40)); 5], None);
1701 factual.facts_text = "f".repeat(400);
1702 factual.facts_present = true;
1703 let plan = plan_migration(&factual, budget(120), &cancel)
1704 .await
1705 .unwrap();
1706 assert_eq!(plan.summary.strategy, "truncate");
1707
1708 let ten_tokens = "x".repeat(40);
1711 let long = source(vec![turn(&ten_tokens); 30], None);
1712 let plan = plan_migration(&long, budget(286), &cancel).await.unwrap();
1713 assert_eq!(plan.summary.strategy, "truncate");
1714 assert_eq!(plan.summary.turns_carried, 3);
1715 assert_eq!(plan.summary.turns_summarized, 27);
1716 assert_eq!(plan.source.turns.len(), 4);
1717 assert_eq!(
1718 plan.source.turns[0].content,
1719 "[27 earlier turns omitted during migration]"
1720 );
1721 let fits = source(vec![turn(&ten_tokens); 30], None);
1723 let plan = plan_migration(&fits, budget(300), &cancel).await.unwrap();
1724 assert_eq!(plan.summary.strategy, "none");
1725 let persona = "p".repeat(400);
1727 let reserved = source(vec![turn(&ten_tokens); 5], Some(&persona));
1728 let plan = plan_migration(&reserved, budget(120), &cancel)
1729 .await
1730 .unwrap();
1731 assert_eq!(plan.summary.strategy, "truncate");
1732 let only_persona = source(Vec::new(), Some(&persona));
1734 let plan = plan_migration(&only_persona, budget(10), &cancel)
1735 .await
1736 .unwrap();
1737 assert!(plan.source.turns.is_empty());
1738 assert_eq!(plan.summary.strategy, "none");
1739 }
1740
1741 #[tokio::test]
1742 async fn reembedding_needs_a_plausible_target_dimension() {
1743 let cancel = CancellationToken::new();
1744 let mut indexed = source(Vec::new(), None);
1745 indexed.embedding = Some(SourceEmbedding {
1746 meta: EmbeddingMeta {
1747 model: "old".into(),
1748 dimension: 2,
1749 },
1750 chunks: vec![Chunk {
1751 id: "a".into(),
1752 text: "x".into(),
1753 ts: "t".into(),
1754 }],
1755 vectors: vec![Vector {
1756 id: "a".into(),
1757 vector: vec![1.0, 2.0],
1758 }],
1759 });
1760 let embedder = Fixed("new", 3);
1761 for (dimension, ok) in [
1762 (Some(3), true),
1763 (Some(0), false),
1764 (Some(100_001), false),
1765 (None, false),
1766 ] {
1767 let options = MigrationOptions {
1768 embedder: Some(&embedder),
1769 target_dimension: dimension,
1770 ..budget(1000)
1771 };
1772 let result = plan_migration(&indexed, options, &cancel).await;
1773 match result {
1774 Ok(plan) => {
1775 assert!(ok, "{dimension:?}");
1776 assert_eq!(plan.summary.embedding_strategy, "reembed");
1777 }
1778 Err(error) => {
1779 assert!(!ok, "{dimension:?}");
1780 assert_eq!(error.0, "target embedding dimension required");
1781 }
1782 }
1783 }
1784 }
1785
1786 #[cfg(unix)]
1787 mod store {
1788 use super::*;
1789 use std::os::unix::fs::PermissionsExt;
1790
1791 fn private_file(path: &Path, bytes: &[u8]) {
1792 fs::write(path, bytes).unwrap();
1793 fs::set_permissions(path, fs::Permissions::from_mode(0o600)).unwrap();
1794 }
1795 fn private_dir(path: &Path) {
1796 fs::create_dir_all(path).unwrap();
1797 fs::set_permissions(path, fs::Permissions::from_mode(0o700)).unwrap();
1798 }
1799 fn capture_options(timestamp: &str) -> CaptureOptions<'_> {
1800 CaptureOptions {
1801 timestamp,
1802 embedder: None,
1803 embedding_unsupported: false,
1804 }
1805 }
1806
1807 #[test]
1808 fn private_directory_refuses_files() {
1809 let root = tempfile::tempdir().unwrap();
1810 let file = root.path().join("file");
1811 private_file(&file, b"x");
1812 assert!(private_directory(&file).is_err());
1813 let created = root.path().join("a/b");
1814 private_directory(&created).unwrap();
1815 assert!(created.is_dir());
1816 }
1817
1818 #[test]
1819 fn store_directory_replaced_by_a_file_is_unsafe() {
1820 let root = tempfile::tempdir().unwrap();
1821 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
1822 fs::remove_dir_all(&store.dir).unwrap();
1823 private_file(&store.dir, b"{}");
1824 let error = MemoryStore::existing(root.path(), "model").unwrap_err();
1825 assert_eq!(error.0, "unsafe memory directory");
1826 }
1827
1828 #[test]
1829 fn metadata_rewrites_keep_their_owner() {
1830 let root = tempfile::tempdir().unwrap();
1831 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
1832 let guard = store.lock().unwrap();
1833 let mut edited = store.meta.clone();
1834 edited.embedding_unsupported = Some(true);
1835 store.write_meta(&guard, &edited).unwrap();
1836 assert_eq!(store.read_meta().unwrap(), edited);
1837 edited.model_id = "other".into();
1838 assert!(store.write_meta(&guard, &edited).is_err());
1839 guard.release().unwrap();
1840 }
1841
1842 #[test]
1843 fn scan_allows_forty_levels_and_1024_entries() {
1844 let root = tempfile::tempdir().unwrap();
1845 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
1846 let mut nested = store.dir.clone();
1847 for level in 0..40 {
1848 nested = nested.join(format!("d{level}"));
1849 }
1850 private_dir(&nested);
1851 assert!(store.files().is_ok());
1852 private_dir(&nested.join("deeper"));
1853 assert!(store.files().is_err());
1854 fs::remove_dir_all(store.dir.join("d0")).unwrap();
1855 for index in 0..1023 {
1857 private_file(&store.dir.join(format!("f{index}")), b"");
1858 }
1859 assert_eq!(store.files().unwrap().len(), 1024);
1860 private_file(&store.dir.join("f1023"), b"");
1861 assert!(store.files().is_err());
1862 }
1863
1864 #[test]
1865 fn scan_applies_per_file_and_total_size_caps() {
1866 let root = tempfile::tempdir().unwrap();
1867 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
1868 let mib = 1024 * 1024;
1869 private_file(&store.dir.join("facts.json"), &vec![b' '; mib + 1]);
1870 assert!(store.files().is_err());
1871 fs::remove_file(store.dir.join("facts.json")).unwrap();
1872 private_dir(&store.dir.join("embeddings"));
1873 private_file(
1874 &store.dir.join("embeddings/vectors.jsonl"),
1875 &vec![b' '; 10 * mib],
1876 );
1877 private_file(&store.dir.join("notes.txt"), &vec![b' '; 8 * mib]);
1878 assert!(store.files().is_ok());
1879 private_file(&store.dir.join("notes.txt"), &vec![b' '; 8 * mib + 1]);
1880 assert!(store.files().is_err());
1881 fs::remove_dir_all(store.dir.join("embeddings")).unwrap();
1882 fs::remove_file(store.dir.join("notes.txt")).unwrap();
1883 let meta = fs::metadata(store.dir.join("meta.json")).unwrap().len() as usize;
1885 for index in 0..7 {
1886 private_file(
1887 &store.dir.join(format!("part{index}")),
1888 &vec![b' '; 8 * mib],
1889 );
1890 }
1891 private_file(&store.dir.join("part7"), &vec![b' '; 8 * mib - meta]);
1892 assert!(store.files().is_ok());
1893 private_file(&store.dir.join("extra"), b" ");
1894 assert_eq!(store.files().unwrap_err().0, "memory store exceeds limit");
1895 }
1896
1897 #[test]
1898 fn scan_caps_metadata_at_16_kib() {
1899 let root = tempfile::tempdir().unwrap();
1900 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
1901 let path = store.dir.join("meta.json");
1902 let mut raw = fs::read(&path).unwrap();
1903 raw.resize(16384, b' ');
1904 private_file(&path, &raw);
1905 assert!(store.files().is_ok());
1906 raw.push(b' ');
1907 private_file(&path, &raw);
1908 assert!(store.files().is_err());
1909 }
1910
1911 #[test]
1912 fn move_recovery_refuses_a_parked_store_for_another_source() {
1913 let root = tempfile::tempdir().unwrap();
1914 MemoryStore::open(root.path(), "model", "now").unwrap();
1915 let parked = MemoryStore::open(root.path(), "src", "now").unwrap();
1916 let recovery = format!("memory-moved-{}", uuid::Uuid::new_v4());
1917 let journal = transaction(root.path());
1918 fs::rename(&parked.dir, root.path().join(".staging").join(&recovery)).unwrap();
1919 private_file(&journal.join("phase"), b"prepared\n");
1920 private_file(
1921 &journal.join("move.json"),
1922 serde_json::json!({"source": "other", "recovery": recovery})
1923 .to_string()
1924 .as_bytes(),
1925 );
1926 let error = MemoryStore::existing(root.path(), "model").unwrap_err();
1927 assert_eq!(error.0, "ambiguous source recovery; bytes retained");
1928 assert!(!root.path().join("memory/other").exists());
1929 }
1930
1931 fn transaction(root: &Path) -> PathBuf {
1932 let path = root.join(".staging").join("memory-model");
1933 private_dir(&path);
1934 path
1935 }
1936
1937 #[test]
1938 fn a_journal_without_a_phase_is_an_abandoned_staging_area() {
1939 let root = tempfile::tempdir().unwrap();
1940 MemoryStore::open(root.path(), "model", "now").unwrap();
1941 let journal = transaction(root.path());
1942 MemoryStore::existing(root.path(), "model").unwrap();
1943 assert!(!journal.exists());
1944 }
1945
1946 #[test]
1947 fn unreadable_journal_files_stop_recovery() {
1948 let root = tempfile::tempdir().unwrap();
1949 MemoryStore::open(root.path(), "model", "now").unwrap();
1950 let journal = transaction(root.path());
1951 private_file(&journal.join("phase"), &[b'x'; 100]);
1952 assert!(MemoryStore::existing(root.path(), "model").is_err());
1953 private_file(&journal.join("phase"), b"committed\n");
1954 private_file(&journal.join("move.json"), &vec![b' '; 20_000]);
1955 assert!(MemoryStore::existing(root.path(), "model").is_err());
1956 }
1957
1958 #[tokio::test]
1959 async fn capture_input_caps_are_inclusive() {
1960 let root = tempfile::tempdir().unwrap();
1961 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
1962 let cancel = CancellationToken::new();
1963 let invalid = "memory: invalid capture input";
1964 let error = |result: Result<CaptureResult, MemoryError>| {
1965 result.err().map(|error| error.to_string())
1966 };
1967 let limit = 8 * 1024 * 1024;
1968 let over = "x".repeat(limit + 1);
1969 assert_eq!(
1970 error(
1971 store
1972 .capture(&over, "", capture_options("t"), &cancel)
1973 .await
1974 )
1975 .as_deref(),
1976 Some(invalid)
1977 );
1978 let half = "x".repeat(limit / 2 + 1);
1979 assert_eq!(
1980 error(
1981 store
1982 .capture(&half, &half, capture_options("t"), &cancel)
1983 .await
1984 )
1985 .as_deref(),
1986 Some(invalid)
1987 );
1988 let exact = "x".repeat(limit);
1989 assert_ne!(
1990 error(
1991 store
1992 .capture(&exact, "", capture_options("t"), &cancel)
1993 .await
1994 )
1995 .as_deref(),
1996 Some(invalid)
1997 );
1998 for timestamp in [String::new(), "t".repeat(1025)] {
1999 assert_eq!(
2000 error(
2001 store
2002 .capture("hi", "", capture_options(×tamp), &cancel)
2003 .await
2004 )
2005 .as_deref(),
2006 Some(invalid)
2007 );
2008 }
2009 let timestamp = "t".repeat(1024);
2010 store
2011 .capture("hi", "", capture_options(×tamp), &cancel)
2012 .await
2013 .unwrap();
2014 }
2015
2016 #[tokio::test]
2017 async fn capture_keeps_one_embedding_space_and_leaves_facts_alone() {
2018 let root = tempfile::tempdir().unwrap();
2019 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
2020 let cancel = CancellationToken::new();
2021 let embedder = Fixed("embed", 2);
2022 let with = |embedder: &'static Fixed| CaptureOptions {
2023 timestamp: "t",
2024 embedder: Some(embedder),
2025 embedding_unsupported: false,
2026 };
2027 let embedder: &'static Fixed = Box::leak(Box::new(embedder));
2028 store
2029 .capture("hi", "hello", with(embedder), &cancel)
2030 .await
2031 .unwrap();
2032 let again = store
2033 .capture("hi", "hello", with(embedder), &cancel)
2034 .await
2035 .unwrap();
2036 assert_eq!(again.vectors_embedded, 2);
2037 let other: &'static Fixed = Box::leak(Box::new(Fixed("embed", 3)));
2038 assert!(store.capture("hi", "", with(other), &cancel).await.is_err());
2039 let unnamed: &'static Fixed = Box::leak(Box::new(Fixed("", 2)));
2040 let fresh = MemoryStore::open(root.path(), "fresh", "now").unwrap();
2041 assert_eq!(
2042 fresh
2043 .capture("hi", "", with(unnamed), &cancel)
2044 .await
2045 .unwrap_err()
2046 .0,
2047 "embedding space mismatch"
2048 );
2049 let compact = r#"{"schemaVersion":1,"facts":[{"text":"name = Ada","ts":"t"}]}"#;
2051 private_file(&store.dir.join("facts.json"), compact.as_bytes());
2052 store
2053 .capture("nothing to remember", "", capture_options("t"), &cancel)
2054 .await
2055 .unwrap();
2056 assert_eq!(
2057 fs::read_to_string(store.dir.join("facts.json")).unwrap(),
2058 compact
2059 );
2060 }
2061
2062 #[tokio::test]
2063 async fn a_prepared_migration_only_commits_on_its_own_source() {
2064 let root = tempfile::tempdir().unwrap();
2065 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
2066 let cancel = CancellationToken::new();
2067 let prepared = store
2068 .prepare_migration("target", budget(1000), &cancel)
2069 .await
2070 .unwrap();
2071 let mut renamed = store.clone();
2072 renamed.meta.model_id = "imposter".into();
2073 let error = renamed
2074 .commit_migration(prepared, "now", false, &cancel)
2075 .err()
2076 .unwrap();
2077 assert_eq!(error.0, "prepared migration belongs to another source");
2078 }
2079
2080 #[tokio::test]
2081 async fn capture_writes_facts_when_missing_or_when_one_is_learned() {
2082 let root = tempfile::tempdir().unwrap();
2083 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
2084 let cancel = CancellationToken::new();
2085 let facts = store.dir.join("facts.json");
2086 assert!(!facts.exists());
2087 store
2088 .capture("nothing to remember", "", capture_options("t"), &cancel)
2089 .await
2090 .unwrap();
2091 assert!(facts.exists());
2092 let compact = r#"{"schemaVersion":1,"facts":[{"text":"name = Ada","ts":"t"}]}"#;
2093 private_file(&facts, compact.as_bytes());
2094 store
2095 .capture("I live in Paris", "", capture_options("t"), &cancel)
2096 .await
2097 .unwrap();
2098 let written = fs::read_to_string(&facts).unwrap();
2099 assert!(written.contains("name = Ada"), "{written}");
2100 assert!(written.contains("location = Paris"), "{written}");
2101 }
2102
2103 #[tokio::test]
2104 async fn a_migration_commits_into_the_target_and_can_retire_the_source() {
2105 let root = tempfile::tempdir().unwrap();
2106 let cancel = CancellationToken::new();
2107 let store = MemoryStore::open(root.path(), "model", "now").unwrap();
2108 store
2109 .capture("hi", "hello", capture_options("t"), &cancel)
2110 .await
2111 .unwrap();
2112 MemoryStore::open(root.path(), "target", "now").unwrap();
2114 let stray = root.path().join(".staging").join("memory-target");
2115 private_dir(&stray);
2116 let prepared = store
2117 .prepare_migration("target", budget(1000), &cancel)
2118 .await
2119 .unwrap();
2120 assert!(!stray.exists());
2121 let target = store
2122 .commit_migration(prepared, "later", false, &cancel)
2123 .unwrap();
2124 assert_eq!(target.meta.model_id, "target");
2125 assert_eq!(target.read_meta().unwrap().model_id, "target");
2126 let copied = MemoryStore::snapshot(root.path(), "target").unwrap();
2127 assert_eq!(copied.turns.len(), 2);
2128 assert!(store.dir.exists());
2129 let other = MemoryStore::open(root.path(), "other", "now").unwrap();
2131 let prepared = other
2132 .prepare_migration("fresh", budget(1000), &cancel)
2133 .await
2134 .unwrap();
2135 let fresh = other
2136 .commit_migration(prepared, "later", true, &cancel)
2137 .unwrap();
2138 assert_eq!(fresh.read_meta().unwrap().model_id, "fresh");
2139 assert!(!other.dir.exists());
2140 }
2141 }
2142}