Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

Merge remote-tracking branch 'upstream/main' into feature/admission-webhooks

Djalma Júniorfc95f816b8ff
diff --cc crates/ai-memory-mcp/src/server.rs
index 890cfdb6,36272e16..8d3086d5
--- a/crates/ai-memory-mcp/src/server.rs
+++ b/crates/ai-memory-mcp/src/server.rs
@@@ -1936,29 -2115,17 +2200,30 @@@ mod tests
let server = AiMemoryServer::new(store.reader.clone(), store.writer.clone(), ws, proj)
.with_wiki(wiki);
+ // Build a synthetic `Parts` so the new `Extension<Parts>` extractor
+ // can be satisfied — no actor headers, so the admission chain
+ // gets a default (anonymous) context, same as a stdio caller.
+ let parts = axum::http::Request::builder()
+ .uri("/mcp")
+ .method("POST")
+ .body(())
+ .unwrap()
+ .into_parts()
+ .0;
let result = server
- .memory_write_page(Parameters(WritePageArgs {
- path: "notes/santander-2025.md".into(),
- body: "# Santander 2025\n\nDurable tax annotation.".into(),
- title: Some("Santander 2025".into()),
- tier: Some("semantic".into()),
- tags: vec!["finance".into()],
- pinned: true,
- project: None,
- workspace: None,
- }))
+ .memory_write_page(
+ Parameters(WritePageArgs {
+ path: "notes/santander-2025.md".into(),
+ body: "# Santander 2025\n\nDurable tax annotation.".into(),
+ title: Some("Santander 2025".into()),
+ tier: Some("semantic".into()),
+ tags: vec!["finance".into()],
+ pinned: true,
+ project: None,
++ workspace: None,
+ }),
+ rmcp::handler::server::tool::Extension(parts),
+ )
.await
.unwrap();
let text = result
@@@ -1989,94 -2156,80 +2254,180 @@@
);
}
+ #[tokio::test]
+ async fn memory_delete_page_removes_the_page() {
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let ws = store
+ .writer
+ .get_or_create_workspace("default")
+ .await
+ .unwrap();
+ let proj = store
+ .writer
+ .get_or_create_project(ws, "scratch", None)
+ .await
+ .unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();
+ let server = AiMemoryServer::new(store.reader.clone(), store.writer.clone(), ws, proj)
+ .with_wiki(wiki);
-
+ let parts = || {
+ axum::http::Request::builder()
+ .uri("/mcp")
+ .method("POST")
+ .body(())
+ .unwrap()
+ .into_parts()
+ .0
+ };
+
+ server
+ .memory_write_page(
+ Parameters(WritePageArgs {
+ path: "notes/temp.md".into(),
+ body: "# Temp\n\nthrowaway".into(),
+ title: Some("Temp".into()),
+ tier: Some("semantic".into()),
+ tags: vec![],
+ pinned: false,
+ project: None,
++ workspace: None,
+ }),
+ rmcp::handler::server::tool::Extension(parts()),
+ )
+ .await
+ .unwrap();
+
+ server
+ .memory_delete_page(
+ Parameters(DeletePageArgs {
+ path: "notes/temp.md".into(),
+ project: None,
+ }),
+ rmcp::handler::server::tool::Extension(parts()),
+ )
+ .await
+ .unwrap();
+
+ // The on-disk file is gone; reading it back errors (file not found).
+ let read = server
+ .memory_read_page(Parameters(ReadPageArgs {
+ query: None,
+ path: Some("notes/temp.md".into()),
+ project: None,
+ }))
+ .await;
+ assert!(read.is_err(), "deleted page must not be readable");
+
+ // Regression: the derived index row must also be gone — the watcher
+ // does not reconcile deletions, so a file-only delete would leave the
+ // page surfacing in recent/search with stale content.
+ let recent = server
+ .memory_recent(Parameters(RecentArgs {
+ limit: Some(10),
+ project: None,
+ workspace: None,
+ }))
+ .await
+ .unwrap();
+ let recent_text = recent
+ .content
+ .first()
+ .and_then(|c| c.as_text())
+ .map(|t| t.text.clone())
+ .unwrap();
+ assert!(
+ !recent_text.contains("notes/temp.md"),
+ "deleted page must not linger in the index; got {recent_text}"
+ );
+ }
+
+ #[tokio::test]
+ async fn memory_write_page_creates_explicit_project() {
+ // Bug B regression: an explicit `project` that doesn't exist yet must
+ // be created and written to — NOT silently land in the current project.
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let ws = store
+ .writer
+ .get_or_create_workspace("default")
+ .await
+ .unwrap();
+ let baked = store
+ .writer
+ .get_or_create_project(ws, "scratch", None)
+ .await
+ .unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();
+ let server = AiMemoryServer::new(store.reader.clone(), store.writer.clone(), ws, baked)
+ .with_wiki(wiki);
++ let parts = || {
++ axum::http::Request::builder()
++ .uri("/mcp")
++ .method("POST")
++ .body(())
++ .unwrap()
++ .into_parts()
++ .0
++ };
+
+ server
- .memory_write_page(Parameters(WritePageArgs {
- path: "notes/elsewhere.md".into(),
- body: "lands in `other`, not `scratch`".into(),
- title: None,
- tier: Some("semantic".into()),
- tags: vec![],
- pinned: false,
- project: Some("other".into()),
- workspace: None,
- }))
++ .memory_write_page(
++ Parameters(WritePageArgs {
++ path: "notes/elsewhere.md".into(),
++ body: "lands in `other`, not `scratch`".into(),
++ title: None,
++ tier: Some("semantic".into()),
++ tags: vec![],
++ pinned: false,
++ project: Some("other".into()),
++ workspace: None,
++ }),
++ rmcp::handler::server::tool::Extension(parts()),
++ )
+ .await
+ .unwrap();
+
+ // Visible in `other` (created), absent from the baked `scratch`.
+ let in_other = server
+ .memory_recent(Parameters(RecentArgs {
+ limit: Some(5),
+ project: Some("other".into()),
+ workspace: None,
+ }))
+ .await
+ .unwrap();
+ let other_text = in_other
+ .content
+ .first()
+ .and_then(|c| c.as_text())
+ .map(|t| t.text.clone())
+ .unwrap();
+ assert!(
+ other_text.contains("notes/elsewhere.md"),
+ "explicit project must be created + written; got {other_text}"
+ );
+
+ let in_scratch = server
+ .memory_recent(Parameters(RecentArgs {
+ limit: Some(5),
+ project: None,
+ workspace: None,
+ }))
+ .await
+ .unwrap();
+ let scratch_text = in_scratch
+ .content
+ .first()
+ .and_then(|c| c.as_text())
+ .map(|t| t.text.clone())
+ .unwrap();
+ assert!(
+ !scratch_text.contains("notes/elsewhere.md"),
+ "write must not leak into the current project; got {scratch_text}"
+ );
+ }
+
/// `memory_handoff_begin` must resolve the same project as
/// `memory_briefing` when hooks publish `ActiveProject` (issue #2).
#[tokio::test]
@@@ -2226,6 -2381,81 +2579,93 @@@
);
}
+ #[tokio::test]
+ async fn memory_forget_sweep_targets_the_explicit_project() {
+ // Bug C regression: sweep must evaluate the project named in args (or
+ // the session's active project), NOT the baked default. An episodic
+ // page in `audited` is a sweep candidate only when the sweep points
+ // there — never when it runs against the baked `scratch`.
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let ws = store
+ .writer
+ .get_or_create_workspace("default")
+ .await
+ .unwrap();
+ let baked = store
+ .writer
+ .get_or_create_project(ws, "scratch", None)
+ .await
+ .unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();
+ let server = AiMemoryServer::new(store.reader.clone(), store.writer.clone(), ws, baked)
+ .with_wiki(wiki);
++ let parts = || {
++ axum::http::Request::builder()
++ .uri("/mcp")
++ .method("POST")
++ .body(())
++ .unwrap()
++ .into_parts()
++ .0
++ };
+
+ server
- .memory_write_page(Parameters(WritePageArgs {
- path: "log/ep.md".into(),
- body: "episodic note".into(),
- title: None,
- tier: Some("episodic".into()),
- tags: vec![],
- pinned: false,
- project: Some("audited".into()),
- workspace: None,
- }))
++ .memory_write_page(
++ Parameters(WritePageArgs {
++ path: "log/ep.md".into(),
++ body: "episodic note".into(),
++ title: None,
++ tier: Some("episodic".into()),
++ tags: vec![],
++ pinned: false,
++ project: Some("audited".into()),
++ workspace: None,
++ }),
++ rmcp::handler::server::tool::Extension(parts()),
++ )
+ .await
+ .unwrap();
+
+ let sweep_count = |args: SweepArgs| {
+ let server = &server;
+ async move {
+ let out = server.memory_forget_sweep(Parameters(args)).await.unwrap();
+ let text = out
+ .content
+ .first()
+ .and_then(|c| c.as_text())
+ .map(|t| t.text.clone())
+ .unwrap();
+ serde_json::from_str::<serde_json::Value>(&text).unwrap()["candidates_evaluated"]
+ .as_u64()
+ .unwrap()
+ }
+ };
+
+ let audited = sweep_count(SweepArgs {
+ dry_run: Some(true),
+ project: Some("audited".into()),
+ workspace: None,
+ })
+ .await;
+ assert!(
+ audited >= 1,
+ "sweep of the named project must evaluate its episodic page, got {audited}"
+ );
+
+ let baked = sweep_count(SweepArgs {
+ dry_run: Some(true),
+ project: None,
+ workspace: None,
+ })
+ .await;
+ assert_eq!(
+ baked, 0,
+ "sweep of the baked project must not see another project's page, got {baked}"
+ );
+ }
+
/// `memory_handoff_accept` with no pending handoff returns a
/// happy-path `{"handoff": null}` payload (NOT an error). This
/// is the documented contract — the agent can call accept on
diff --cc crates/ai-memory-store/src/ops.rs
index 913e3776,2170c9fe..e5784ce1
--- a/crates/ai-memory-store/src/ops.rs
+++ b/crates/ai-memory-store/src/ops.rs
@@@ -7,8 -7,8 +7,8 @@@
use std::collections::BTreeSet;
use ai_memory_core::{
- AgentKind, HandoffId, NewHandoff, NewObservation, NewPage, NewSession, ObservationId,
- ObservationKind, PageId, PagePath, ProjectId, SessionId, WorkspaceId,
+ AgentKind, HandoffId, LinkTarget, NewHandoff, NewObservation, NewPage, NewSession,
- ObservationId, ObservationKind, PageId, ProjectId, SessionId, WorkspaceId,
++ ObservationId, ObservationKind, PageId, PagePath, ProjectId, SessionId, WorkspaceId,
};
/// Summary returned by [`reorg_sessions`] and exposed via