Skip to content

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

Rust

fix(admin): close scope invalidation races

AkitaOnRails20ace20ba013
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a003c4f2..39837d17 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
the unused LLM retry-exhaustion error variant was removed ([#171]).
### Fixed
+- Admin scope mutations now invalidate both legacy and keyed active-project
+ state plus hook project caches: project moves retarget live active entries,
+ workspace deletes clear affected active/cache entries so deleted scopes are
+ not recreated by the next hook, and workspace rename manifest refresh
+ failures return success with an explicit warning after the committed SQLite
+ rename instead of a misleading 500.
- `/hook/batch` now skips per-source rate-limited items and continues accepting
later unrelated sources, returns non-contiguous acknowledgements for new spool
drains, bounds limiter key bytes, keys by actor+session with deterministic
diff --git a/crates/ai-memory-cli/src/commands/serve.rs b/crates/ai-memory-cli/src/commands/serve.rs
index b95337b9..a3290984 100644
--- a/crates/ai-memory-cli/src/commands/serve.rs
+++ b/crates/ai-memory-cli/src/commands/serve.rs
@@ -15,7 +15,7 @@ use ai_memory_hooks::{
DEFAULT_HOOK_INGEST_MAX_IN_FLIGHT, HookState, ProjectCacheStore, hook_router,
};
use ai_memory_llm::{Embedder, LlmProvider, ProviderHealth, build_embedder, build_provider};
-use ai_memory_mcp::{AdminState, AiMemoryServer, admin_router};
+use ai_memory_mcp::{AdminState, AiMemoryServer, ScopeInvalidation, admin_router};
use ai_memory_store::{
ApproveAutoImproveProposalResult, AutoImproveProposalOperation, EmbeddingWrite,
NewAutoImproveProposal, ReaderPool, StageAutoImproveRun, Store, WriterHandle, f32_vec_to_bytes,
@@ -259,18 +259,25 @@ pub async fn run(config: &Config, args: ServeArgs) -> Result<()> {
.with_json_response(!args.http_stateful),
);
// Shared per-cwd project cache: the hook router owns it; the admin
- // router gets a fire-and-forget eviction hook so a `move-project`
- // can proactively drop the moved project's stale entries.
+ // router gets an awaited eviction hook so scope mutations can
+ // proactively drop stale entries before the next hook re-resolves.
let project_cache: ai_memory_hooks::ProjectCache =
std::sync::Arc::new(tokio::sync::Mutex::new(ProjectCacheStore::default()));
- let on_project_moved: std::sync::Arc<dyn Fn(ProjectId) + Send + Sync> = {
+ let scope_invalidator: ai_memory_mcp::ScopeInvalidator = {
let cache = project_cache.clone();
- std::sync::Arc::new(move |proj: ProjectId| {
- let cache = cache.clone();
- tokio::spawn(async move {
- cache.lock().await.retain(|_, v| v.1 != proj);
- });
- })
+ std::sync::Arc::new(
+ move |target: ScopeInvalidation| -> std::pin::Pin<
+ Box<dyn std::future::Future<Output = ()> + Send + 'static>,
+ > {
+ let cache = cache.clone();
+ Box::pin(async move {
+ cache.lock().await.retain(|_, v| match target {
+ ScopeInvalidation::Project(proj) => v.1 != proj,
+ ScopeInvalidation::Workspace(ws) => v.0 != ws,
+ });
+ })
+ },
+ )
};
let hooks = hook_router(HookState {
workspace_id: ws,
@@ -325,7 +332,7 @@ pub async fn run(config: &Config, args: ServeArgs) -> Result<()> {
.filter(|p| !p.trim().is_empty())
.map(|p| ai_memory_store::TokenPepper::new(p.clone())),
active_project: active_project.clone(),
- on_project_moved: Some(on_project_moved),
+ scope_invalidator: Some(scope_invalidator),
});
// Multi-rung auth assembly:
// - rung 0 (no bearer_token configured) → AuthState::new
diff --git a/crates/ai-memory-core/src/active_project.rs b/crates/ai-memory-core/src/active_project.rs
index 93f61714..bc184dbc 100644
--- a/crates/ai-memory-core/src/active_project.rs
+++ b/crates/ai-memory-core/src/active_project.rs
@@ -175,6 +175,37 @@ impl PerActorMap {
self.entries.get(key).map(|(ws, proj, _)| (*ws, *proj))
}
+ fn retarget_project(&mut self, project_id: ProjectId, workspace_id: WorkspaceId, now: Instant) {
+ self.purge_expired(now);
+ for (ws, proj, _) in self.entries.values_mut() {
+ if *proj == project_id {
+ *ws = workspace_id;
+ }
+ }
+ }
+
+ fn clear_project(&mut self, project_id: ProjectId, now: Instant) {
+ self.purge_expired(now);
+ self.entries.retain(|_, (_, proj, _)| *proj != project_id);
+ }
+
+ fn clear_workspace(&mut self, workspace_id: WorkspaceId, now: Instant) {
+ self.purge_expired(now);
+ self.entries.retain(|_, (ws, _, _)| *ws != workspace_id);
+ }
+
+ fn contains_project(&mut self, project_id: ProjectId, now: Instant) -> bool {
+ self.purge_expired(now);
+ self.entries
+ .values()
+ .any(|(_, proj, _)| *proj == project_id)
+ }
+
+ fn contains_workspace(&mut self, workspace_id: WorkspaceId, now: Instant) -> bool {
+ self.purge_expired(now);
+ self.entries.values().any(|(ws, _, _)| *ws == workspace_id)
+ }
+
/// Test-only: live row count in the backing HashMap. Counts all
/// rows, including ones whose TTL has elapsed (those are dropped
/// by `purge_expired` on the next read/write). The randomised cap
@@ -355,6 +386,66 @@ impl ActiveProject {
guard.entries.clear();
}
+ /// Retarget every active entry for `project_id` to `workspace_id`, preserving
+ /// the project id. Used after a lossless cross-workspace move where the
+ /// project row survives and only its workspace changes.
+ pub fn retarget_project_workspace(&self, project_id: ProjectId, workspace_id: WorkspaceId) {
+ {
+ let mut guard = self.single.write().unwrap_or_else(|e| e.into_inner());
+ if let Some((ws, proj)) = guard.as_mut()
+ && *proj == project_id
+ {
+ *ws = workspace_id;
+ }
+ }
+ let mut guard = self.per_actor.write().unwrap_or_else(|e| e.into_inner());
+ guard.retarget_project(project_id, workspace_id, Instant::now());
+ }
+
+ /// Clear every active entry whose project id matches `project_id`.
+ pub fn clear_project(&self, project_id: ProjectId) {
+ {
+ let mut guard = self.single.write().unwrap_or_else(|e| e.into_inner());
+ if guard.map(|(_, proj)| proj) == Some(project_id) {
+ *guard = None;
+ }
+ }
+ let mut guard = self.per_actor.write().unwrap_or_else(|e| e.into_inner());
+ guard.clear_project(project_id, Instant::now());
+ }
+
+ /// Clear every active entry whose workspace id matches `workspace_id`.
+ pub fn clear_workspace(&self, workspace_id: WorkspaceId) {
+ {
+ let mut guard = self.single.write().unwrap_or_else(|e| e.into_inner());
+ if guard.map(|(ws, _)| ws) == Some(workspace_id) {
+ *guard = None;
+ }
+ }
+ let mut guard = self.per_actor.write().unwrap_or_else(|e| e.into_inner());
+ guard.clear_workspace(workspace_id, Instant::now());
+ }
+
+ /// Whether any live active entry references `project_id`.
+ #[must_use]
+ pub fn contains_project(&self, project_id: ProjectId) -> bool {
+ if self.read_single().map(|(_, proj)| proj) == Some(project_id) {
+ return true;
+ }
+ let mut guard = self.per_actor.write().unwrap_or_else(|e| e.into_inner());
+ guard.contains_project(project_id, Instant::now())
+ }
+
+ /// Whether any live active entry references `workspace_id`.
+ #[must_use]
+ pub fn contains_workspace(&self, workspace_id: WorkspaceId) -> bool {
+ if self.read_single().map(|(ws, _)| ws) == Some(workspace_id) {
+ return true;
+ }
+ let mut guard = self.per_actor.write().unwrap_or_else(|e| e.into_inner());
+ guard.contains_workspace(workspace_id, Instant::now())
+ }
+
/// Test-only: look up only the per-key backing store. Used to prove
/// eviction in tests without depending on the public fallback semantics.
#[cfg(test)]
@@ -457,6 +548,74 @@ mod tests {
assert!(ap.get().is_none(), "single slot must be gone");
}
+ #[test]
+ fn retarget_project_workspace_updates_single_and_keyed_entries() {
+ let ap = ActiveProject::with_mode(ActiveProjectMode::PerActor);
+ let alice = key_actor("alice", "sA");
+ let bob = key_actor("bob", "sB");
+ let old_ws = WorkspaceId::new();
+ let new_ws = WorkspaceId::new();
+ let moved = ProjectId::new();
+ let other = ProjectId::new();
+
+ ap.set_for(&alice, old_ws, moved);
+ ap.set_for(&bob, old_ws, other);
+ ap.set(old_ws, moved);
+
+ ap.retarget_project_workspace(moved, new_ws);
+
+ assert_eq!(ap.get(), Some((new_ws, moved)));
+ assert_eq!(ap.get_for(&alice), Some((new_ws, moved)));
+ assert_eq!(ap.get_for(&bob), Some((old_ws, other)));
+ assert!(ap.contains_project(moved));
+ assert!(ap.contains_workspace(new_ws));
+ }
+
+ #[test]
+ fn clear_project_drops_matching_single_and_keyed_entries_only() {
+ let ap = ActiveProject::with_mode(ActiveProjectMode::PerActor);
+ let alice = key_actor("alice", "sA");
+ let bob = key_actor("bob", "sB");
+ let ws = WorkspaceId::new();
+ let doomed = ProjectId::new();
+ let kept = ProjectId::new();
+
+ ap.set_for(&alice, ws, doomed);
+ ap.set_for(&bob, ws, kept);
+ ap.set(ws, doomed);
+
+ ap.clear_project(doomed);
+
+ assert!(ap.get().is_none());
+ assert!(ap.get_for(&alice).is_none());
+ assert_eq!(ap.get_for(&bob), Some((ws, kept)));
+ assert!(!ap.contains_project(doomed));
+ assert!(ap.contains_project(kept));
+ }
+
+ #[test]
+ fn clear_workspace_drops_matching_single_and_keyed_entries_only() {
+ let ap = ActiveProject::with_mode(ActiveProjectMode::PerActor);
+ let alice = key_actor("alice", "sA");
+ let bob = key_actor("bob", "sB");
+ let doomed_ws = WorkspaceId::new();
+ let kept_ws = WorkspaceId::new();
+ let p1 = ProjectId::new();
+ let p2 = ProjectId::new();
+
+ ap.set_for(&alice, doomed_ws, p1);
+ ap.set_for(&bob, kept_ws, p2);
+ ap.set(doomed_ws, p1);
+
+ ap.clear_workspace(doomed_ws);
+
+ assert!(ap.get().is_none());
+ assert!(ap.get_for(&alice).is_none());
+ assert_eq!(ap.get_for(&bob), Some((kept_ws, p2)));
+ assert!(!ap.contains_workspace(doomed_ws));
+ assert!(ap.contains_workspace(kept_ws));
+ }
+
#[test]
fn single_mode_ignores_actor_coordinates() {
let ap = ActiveProject::new();
diff --git a/crates/ai-memory-hooks/src/lib.rs b/crates/ai-memory-hooks/src/lib.rs
index 747ee997..c5514309 100644
--- a/crates/ai-memory-hooks/src/lib.rs
+++ b/crates/ai-memory-hooks/src/lib.rs
@@ -4,16 +4,16 @@
//!
//! 1. The agent CLI (Claude Code, Codex, OpenCode) emits a lifecycle event
//! JSON over stdin to one of the vendored hook scripts under `hooks/`.
-//! 2. The script `curl`s the JSON to `POST /hook?event=<kind>&agent=<kind>`
-//! on the running ai-memory server with a sub-second timeout. The
-//! script exits 0 unconditionally so the agent never blocks on us
-//! (lesson from agentmemory #221 — hooks that `await` REST round-trips
-//! can deadlock the engine under fan-out).
-//! 3. The server parses the body as JSON, runs it through the
-//! [`ai_memory_core::Sanitizer`] redaction layer, and forwards a
-//! [`ai_memory_core::Sanitized<NewObservation>`] to the store writer.
-//! On `SessionEnd` it also synthesises a wiki page summarising the
-//! session via [`synth`].
+//! 2. Native hook commands spool events locally and drain them to
+//! `POST /hook/batch` (or `POST /hook?event=<kind>&agent=<kind>` for
+//! direct integrations) with short timeouts. Scripts exit 0 so the agent
+//! never blocks on us (lesson from agentmemory #221 — hooks that `await`
+//! REST round-trips can deadlock the engine under fan-out).
+//! 3. The server parses the body as JSON, runs it through bounded ingest and
+//! the [`ai_memory_core::Sanitizer`] redaction layer, then forwards a
+//! [`ai_memory_core::Sanitized<NewObservation>`] to the store writer. On
+//! `SessionEnd` it also synthesises a wiki page summarising the session via
+//! [`synth`].
//!
//! Privacy strip is a *typed* boundary: there is no way to write an
//! observation without first passing through `Sanitized::new`.
diff --git a/crates/ai-memory-hooks/src/router.rs b/crates/ai-memory-hooks/src/router.rs
index 4c039e51..1b1993a8 100644
--- a/crates/ai-memory-hooks/src/router.rs
+++ b/crates/ai-memory-hooks/src/router.rs
@@ -3496,6 +3496,22 @@ mod tests {
assert_eq!(cache.len(), 2);
}
+ #[test]
+ fn project_cache_store_can_evict_by_workspace_id() {
+ let mut cache = ProjectCacheStore::new(4);
+ let doomed_ws = WorkspaceId::new();
+ let kept_ws = WorkspaceId::new();
+ let key_a = ("/a".into(), String::new(), String::new(), "basename".into());
+ let key_b = ("/b".into(), String::new(), String::new(), "basename".into());
+
+ cache.insert(key_a.clone(), (doomed_ws, ProjectId::new()));
+ cache.insert(key_b.clone(), (kept_ws, ProjectId::new()));
+ cache.retain(|_, (ws, _)| *ws != doomed_ws);
+
+ assert!(!cache.contains_key(&key_a));
+ assert!(cache.contains_key(&key_b));
+ }
+
/// If the cached project is deleted out from under the router (e.g.
/// `purge-project` on a live server), the next event must self-heal:
/// evict the stale slot, recreate the project, and ingest — instead of
diff --git a/crates/ai-memory-mcp/src/admin.rs b/crates/ai-memory-mcp/src/admin.rs
index 5a9dbb1d..b79d1fa4 100644
--- a/crates/ai-memory-mcp/src/admin.rs
+++ b/crates/ai-memory-mcp/src/admin.rs
@@ -18,6 +18,8 @@
//! - `POST /admin/restore-page` — restore one page from a checkpoint.
//! - `POST /admin/purge-project` — delete a project and all its data.
//! - `POST /admin/rename-project` — rename a project (column-only; no files move).
+//! - `POST /admin/rename-workspace` — rename a workspace and refresh scope manifests.
+//! - `POST /admin/delete-workspace` — delete a workspace and all of its projects.
//! - `POST /admin/move-project` — move a project into another workspace
//! (copy latest pages via the write path, then purge the source).
//! - `POST /admin/write-page` — write or update a wiki page atomically.
@@ -30,8 +32,10 @@
use std::sync::Arc;
+use std::future::Future;
use std::io::Seek;
use std::path::PathBuf;
+use std::pin::Pin;
use ai_memory_consolidate::{
AutoImproveReviewConfig, AutoImproveTelemetryParams, AutoImproveTelemetryReport, Bootstrap,
@@ -126,13 +130,32 @@ pub struct AdminState {
/// hook router is attached (admin-only tests).
pub active_project: ActiveProject,
/// Optional hook to PROACTIVELY evict the hook router's per-cwd
- /// `(workspace_id, project_id)` cache for a project that just moved
- /// workspaces. Called with the moved `project_id` after a successful move
- /// so the next hook event re-resolves cleanly instead of tripping the
- /// pairing trigger on a stale cached pair first. Fire-and-forget
- /// (best-effort); the trigger + router re-resolve are the correctness net.
- /// `None` when no hook router is attached (stdio / admin-only tests).
- pub on_project_moved: Option<std::sync::Arc<dyn Fn(ProjectId) + Send + Sync>>,
+ /// `(workspace_id, project_id)` cache after admin scope mutations. Admin
+ /// handlers await this after successful moves/purges/deletes/renames so
+ /// the next hook event re-resolves cleanly instead of racing through a
+ /// stale cached pair. `None` when no hook router is attached (stdio /
+ /// admin-only tests).
+ pub scope_invalidator: Option<ScopeInvalidator>,
+}
+
+/// Async hook-router project-cache invalidator installed by the serve command.
+pub type ScopeInvalidator = Arc<
+ dyn Fn(ScopeInvalidation) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> + Send + Sync,
+>;
+
+/// Hook-router project-cache invalidation target for admin scope mutations.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ScopeInvalidation {
+ /// Evict cache entries whose resolved project id matches.
+ Project(ProjectId),
+ /// Evict cache entries whose resolved workspace id matches.
+ Workspace(WorkspaceId),
+}
+
+async fn invalidate_scope_cache(state: &AdminState, target: ScopeInvalidation) {
+ if let Some(evict) = &state.scope_invalidator {
+ evict(target).await;
+ }
}
/// JSON request body for `POST /admin/bootstrap`.
@@ -2941,6 +2964,9 @@ async fn handle_purge_project(
}
state.wiki.dispatch_purge_project(dispatch_ctx.as_ref());
+ state.active_project.clear_project(proj_id);
+ invalidate_scope_cache(&state, ScopeInvalidation::Project(proj_id)).await;
+
let checkpoint = checkpoint_or_warn(&state.wiki, format!("purge-project {label}"));
let report = PurgeProjectReport {
@@ -2987,6 +3013,9 @@ pub struct RenameWorkspaceResult {
pub checkpoint: Option<String>,
/// Number of scope manifests refreshed after the SQLite rename.
pub manifests_refreshed: usize,
+ /// Non-fatal manifest refresh failure after the SQLite rename committed.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub manifest_warning: Option<String>,
}
/// `POST /admin/rename-workspace` — rename a workspace (column-only; the
@@ -3009,10 +3038,15 @@ async fn handle_rename_workspace(
};
return (status, Json(serde_json::json!({ "error": e.to_string() })));
}
- let manifests_refreshed = match state.wiki.backfill_scope_manifests().await {
- Ok(n) => n,
- Err(e) => return internal_err(e.to_string()),
+ let (manifests_refreshed, manifest_warning) = match state.wiki.backfill_scope_manifests().await
+ {
+ Ok(n) => (n, None),
+ Err(e) => {
+ warn!(error = %e, "rename-workspace: scope-manifest backfill failed after rename");
+ (0, Some(e.to_string()))
+ }
};
+ invalidate_scope_cache(&state, ScopeInvalidation::Workspace(ws_id)).await;
let checkpoint = checkpoint_or_warn(
&state.wiki,
format!("rename-workspace {} -> {}", req.from, req.to),
@@ -3022,6 +3056,7 @@ async fn handle_rename_workspace(
to: req.to.clone(),
checkpoint,
manifests_refreshed,
+ manifest_warning,
};
(
StatusCode::OK,
@@ -3156,6 +3191,9 @@ async fn handle_delete_workspace(
}
state.wiki.dispatch_purge_workspace(dispatch_ctx.as_ref());
+ state.active_project.clear_workspace(ws_id);
+ invalidate_scope_cache(&state, ScopeInvalidation::Workspace(ws_id)).await;
+
let result = DeleteWorkspaceResult {
workspace: req.workspace.clone(),
projects_deleted: summary.projects_deleted,
@@ -3473,13 +3511,11 @@ async fn true_move_project(
// unchanged, only its workspace moved. If a hook had published this project
// as active, republish it under the destination workspace so the next event
// resolves cleanly (rather than tripping the pairing trigger first).
- if state.active_project.get().map(|(_, p)| p) == Some(src_proj) {
- state.active_project.set(dst_ws, src_proj);
- }
+ state
+ .active_project
+ .retarget_project_workspace(src_proj, dst_ws);
// Proactively drop any stale per-cwd cache entry for the moved project.
- if let Some(evict) = &state.on_project_moved {
- evict(src_proj);
- }
+ invalidate_scope_cache(state, ScopeInvalidation::Project(src_proj)).await;
if let Err(e) = state.wiki.backfill_scope_manifests().await {
warn!(error = %e, "true-move: scope-manifest backfill failed after move");
@@ -3634,7 +3670,7 @@ async fn handle_move_project(
// the now-stale workspace id (the (workspace_id, project_id) trigger would
// make it fail, but the operator should consciously opt in). `force: true`
// proceeds — safe because the move republishes the active pointer below.
- if !req.force && state.active_project.get().map(|(_, p)| p) == Some(src_proj) {
+ if !req.force && state.active_project.contains_project(src_proj) {
return (
StatusCode::CONFLICT,
Json(serde_json::json!({
@@ -4114,14 +4150,10 @@ async fn copy_purge_merge(
// The source project_id was just purged; if it was the published active
// project, the pointer now dangles — clear it so the next hook re-resolves
// to the (new) project rather than the deleted id.
- if state.active_project.get().map(|(_, p)| p) == Some(src_proj) {
- state.active_project.clear();
- }
+ state.active_project.clear_project(src_proj);
// Proactively drop any stale per-cwd cache entry for the purged source
// project (its project_id no longer exists).
- if let Some(evict) = &state.on_project_moved {
- evict(src_proj);
- }
+ invalidate_scope_cache(state, ScopeInvalidation::Project(src_proj)).await;
if let Err(e) = state.wiki.backfill_scope_manifests().await {
warn!(error = %e, "copy-purge move: scope-manifest backfill failed after move");
@@ -4796,7 +4828,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
let resp = router
@@ -4839,7 +4871,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
(tmp, router)
}
@@ -4871,7 +4903,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
}
}
@@ -5920,7 +5952,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
post_write_page(&router, "default", "doomed", "notes/x.md", "bye").await;
@@ -6028,7 +6060,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
post_write_page(&router, "default", "doomed", "notes/x.md", "bye").await;
@@ -6129,7 +6161,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
post_write_page(&router, "default", "doomed", "notes/x.md", "bye").await;
@@ -6236,7 +6268,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
post_write_page_with_actor(
@@ -6293,6 +6325,276 @@ mod tests {
assert_eq!(json["source_purged"], true);
}
+ #[tokio::test]
+ async fn move_project_guard_and_true_move_retarget_keyed_active_entries() {
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone())
+ .unwrap()
+ .with_store_reader(store.reader.clone());
+ let active =
+ ai_memory_core::ActiveProject::with_mode(ai_memory_core::ActiveProjectMode::PerActor);
+ let mut state = admin_state_for_store(&tmp, &store, wiki);
+ state.active_project = active.clone();
+ let router = admin_router(state);
+
+ post_write_page(&router, "src", "live", "notes/source.md", "source body").await;
+ let src_ws = store
+ .reader
+ .find_workspace("src".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ let src_proj = store
+ .reader
+ .find_project(src_ws, "live".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ let actor = ai_memory_core::ActorKey {
+ user: Some("alice".into()),
+ session_id: Some("session-1".into()),
+ };
+ active.set_for(&actor, src_ws, src_proj);
+ active.set(WorkspaceId::new(), ProjectId::new());
+
+ let move_body = serde_json::json!({
+ "from_workspace": "src",
+ "project": "live",
+ "to_workspace": "dst",
+ "confirm": true,
+ });
+ let guarded = router
+ .clone()
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/move-project")
+ .header("content-type", "application/json")
+ .body(Body::from(serde_json::to_vec(&move_body).unwrap()))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(guarded.status(), StatusCode::CONFLICT);
+
+ let forced_body = serde_json::json!({
+ "from_workspace": "src",
+ "project": "live",
+ "to_workspace": "dst",
+ "confirm": true,
+ "force": true,
+ });
+ let moved = router
+ .clone()
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/move-project")
+ .header("content-type", "application/json")
+ .body(Body::from(serde_json::to_vec(&forced_body).unwrap()))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(moved.status(), StatusCode::OK);
+ let dst_ws = store
+ .reader
+ .find_workspace("dst".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ assert_eq!(active.get_for(&actor), Some((dst_ws, src_proj)));
+ }
+
+ #[tokio::test]
+ async fn delete_workspace_clears_single_and_keyed_active_entries() {
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone())
+ .unwrap()
+ .with_store_reader(store.reader.clone());
+ let active =
+ ai_memory_core::ActiveProject::with_mode(ai_memory_core::ActiveProjectMode::PerActor);
+ let mut state = admin_state_for_store(&tmp, &store, wiki);
+ state.active_project = active.clone();
+ let router = admin_router(state);
+
+ post_write_page(&router, "doomed-ws", "p", "notes/x.md", "bye").await;
+ let ws = store
+ .reader
+ .find_workspace("doomed-ws".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ let proj = store
+ .reader
+ .find_project(ws, "p".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ let actor = ai_memory_core::ActorKey {
+ user: Some("alice".into()),
+ session_id: Some("session-1".into()),
+ };
+ active.set_for(&actor, ws, proj);
+ active.set(ws, proj);
+
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/delete-workspace")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ serde_json::to_vec(&serde_json::json!({
+ "workspace": "doomed-ws",
+ "force": true,
+ }))
+ .unwrap(),
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ assert!(active.get().is_none());
+ assert!(active.get_for(&actor).is_none());
+ assert!(!active.contains_workspace(ws));
+ }
+
+ fn recording_scope_invalidator(
+ seen: Arc<std::sync::Mutex<Vec<ScopeInvalidation>>>,
+ ) -> ScopeInvalidator {
+ Arc::new(move |target| {
+ let seen = seen.clone();
+ Box::pin(async move {
+ // Prove admin handlers await the invalidator before returning;
+ // constructing and dropping this future would not record.
+ tokio::task::yield_now().await;
+ seen.lock().unwrap().push(target);
+ })
+ })
+ }
+
+ #[tokio::test]
+ async fn delete_workspace_awaits_workspace_cache_invalidation() {
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone())
+ .unwrap()
+ .with_store_reader(store.reader.clone());
+ let seen = Arc::new(std::sync::Mutex::new(Vec::new()));
+ let mut state = admin_state_for_store(&tmp, &store, wiki);
+ state.scope_invalidator = Some(recording_scope_invalidator(seen.clone()));
+ let router = admin_router(state);
+
+ post_write_page(&router, "doomed-ws", "p", "notes/x.md", "bye").await;
+ let ws = store
+ .reader
+ .find_workspace("doomed-ws".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/delete-workspace")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ serde_json::to_vec(&serde_json::json!({
+ "workspace": "doomed-ws",
+ "force": true,
+ }))
+ .unwrap(),
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(resp.status(), StatusCode::OK);
+ assert_eq!(
+ *seen.lock().unwrap(),
+ vec![ScopeInvalidation::Workspace(ws)]
+ );
+ }
+
+ #[tokio::test]
+ async fn copy_purge_move_clears_keyed_active_entries_and_awaits_project_invalidation() {
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone())
+ .unwrap()
+ .with_store_reader(store.reader.clone());
+ let active =
+ ai_memory_core::ActiveProject::with_mode(ai_memory_core::ActiveProjectMode::PerActor);
+ let seen = Arc::new(std::sync::Mutex::new(Vec::new()));
+ let mut state = admin_state_for_store(&tmp, &store, wiki);
+ state.active_project = active.clone();
+ state.scope_invalidator = Some(recording_scope_invalidator(seen.clone()));
+ let router = admin_router(state);
+
+ post_write_page(&router, "src", "merged", "notes/source.md", "source body").await;
+ post_write_page(
+ &router,
+ "dst",
+ "merged",
+ "notes/existing.md",
+ "existing body",
+ )
+ .await;
+ let src_ws = store
+ .reader
+ .find_workspace("src".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ let src_proj = store
+ .reader
+ .find_project(src_ws, "merged".to_string())
+ .await
+ .unwrap()
+ .unwrap();
+ let actor = ai_memory_core::ActorKey {
+ user: Some("alice".into()),
+ session_id: Some("session-1".into()),
+ };
+ active.set_for(&actor, src_ws, src_proj);
+ active.set(src_ws, src_proj);
+
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/move-project")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ serde_json::to_vec(&serde_json::json!({
+ "from_workspace": "src",
+ "project": "merged",
+ "to_workspace": "dst",
+ "confirm": true,
+ "force": true,
+ }))
+ .unwrap(),
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(resp.status(), StatusCode::OK);
+ assert!(active.get().is_none());
+ assert!(active.get_for(&actor).is_none());
+ assert_eq!(
+ *seen.lock().unwrap(),
+ vec![ScopeInvalidation::Project(src_proj)]
+ );
+ }
+
// ── user-management endpoints (P1.4) ──────────────────────────
/// Test router that has a token pepper configured (so user-management
@@ -6322,7 +6624,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: Some(pepper),
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
// Wrap in a middleware that stamps the AuthLevel ourselves —
// the real auth middleware lives in ai-memory-cli, and this
@@ -6881,7 +7183,7 @@ mod tests {
bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
});
// Inject a Root level so we're past the require_root gate;
// the 503 must come from require_pepper.
diff --git a/crates/ai-memory-mcp/src/lib.rs b/crates/ai-memory-mcp/src/lib.rs
index ac178164..ce27090c 100644
--- a/crates/ai-memory-mcp/src/lib.rs
+++ b/crates/ai-memory-mcp/src/lib.rs
@@ -13,5 +13,5 @@ pub mod admin;
mod server;
pub use actor::actor_from_headers;
-pub use admin::{AdminState, admin_router};
+pub use admin::{AdminState, ScopeInvalidation, ScopeInvalidator, admin_router};
pub use server::{AiMemoryServer, MEMORY_INSTRUCTIONS};
diff --git a/crates/ai-memory-mcp/tests/admin_backup.rs b/crates/ai-memory-mcp/tests/admin_backup.rs
index 85dacfd8..4735dcb4 100644
--- a/crates/ai-memory-mcp/tests/admin_backup.rs
+++ b/crates/ai-memory-mcp/tests/admin_backup.rs
@@ -40,7 +40,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
diff --git a/crates/ai-memory-mcp/tests/admin_bootstrap.rs b/crates/ai-memory-mcp/tests/admin_bootstrap.rs
index 21ae7e34..e596d42e 100644
--- a/crates/ai-memory-mcp/tests/admin_bootstrap.rs
+++ b/crates/ai-memory-mcp/tests/admin_bootstrap.rs
@@ -37,7 +37,7 @@ async fn make_admin_state(tmp: &TempDir) -> AdminState {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
}
}
diff --git a/crates/ai-memory-mcp/tests/admin_move.rs b/crates/ai-memory-mcp/tests/admin_move.rs
index 35e3bf0d..41fa0c4a 100644
--- a/crates/ai-memory-mcp/tests/admin_move.rs
+++ b/crates/ai-memory-mcp/tests/admin_move.rs
@@ -55,7 +55,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
@@ -84,7 +84,7 @@ async fn make_state_with_chain(tmp: &TempDir, chain: AdmissionChain) -> (AdminSt
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
@@ -439,7 +439,7 @@ async fn move_project_carries_source_embedding() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
// Seed source page (gets a synthetic embedding on write).
@@ -723,7 +723,7 @@ async fn true_move_notifies_admission_with_destination_names() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
seed_page(&store, &state.wiki, "src", "proj", "notes/a.md", "body a").await;
@@ -777,7 +777,7 @@ async fn make_state_with_embedder(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
@@ -930,7 +930,7 @@ fn build_state(store: &Store, tmp: &TempDir) -> AdminState {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
}
}
@@ -1426,7 +1426,7 @@ async fn true_move_aborts_when_admission_rejects() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
seed_page(&store, &state.wiki, "src", "proj", "notes/a.md", "body a").await;
@@ -1521,7 +1521,7 @@ async fn copy_purge_purge_admission_runs_before_db_destruction() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
// Pre-seed BOTH sides so move-project takes the copy-purge path (merge
// into existing dst/proj), not the lossless true-move path.
@@ -1633,7 +1633,7 @@ async fn move_copy_skips_contributors_webhook_but_runs_others() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
// Pre-seed BOTH sides so the move takes the copy-purge (merge) path.
seed_page(&store, &state.wiki, "src", "proj", "notes/a.md", "body a").await;
@@ -1872,6 +1872,62 @@ async fn rename_workspace_refreshes_scope_manifests() {
assert!(!manifest.contains("workspace: old"), "{manifest}");
}
+#[tokio::test]
+async fn rename_workspace_manifest_refresh_failure_is_nonfatal_after_db_rename() {
+ let tmp = TempDir::new().unwrap();
+ let (state, store) = make_state(&tmp).await;
+ seed_page(&store, &state.wiki, "old", "proj", "notes/a.md", "b").await;
+ state.wiki.backfill_scope_manifests().await.unwrap();
+ let ws_id = store
+ .reader
+ .find_workspace("old".into())
+ .await
+ .unwrap()
+ .expect("workspace exists");
+ let manifest_path = tmp
+ .path()
+ .join("wiki")
+ .join(ws_id.to_string())
+ .join("_meta.md");
+ std::fs::remove_file(&manifest_path).unwrap();
+ std::fs::create_dir(&manifest_path).unwrap();
+
+ let resp = post(
+ state,
+ "/admin/rename-workspace",
+ json!({"from":"old","to":"new"}),
+ )
+ .await;
+
+ assert_eq!(resp.status(), StatusCode::OK);
+ let body = body_json(resp).await;
+ assert_eq!(body["from"], "old");
+ assert_eq!(body["to"], "new");
+ assert_eq!(body["manifests_refreshed"], 0);
+ assert!(
+ body["manifest_warning"]
+ .as_str()
+ .is_some_and(|s| !s.is_empty()),
+ "response should disclose non-fatal manifest refresh failure: {body}"
+ );
+ assert!(
+ store
+ .reader
+ .find_workspace("new".into())
+ .await
+ .unwrap()
+ .is_some()
+ );
+ assert!(
+ store
+ .reader
+ .find_workspace("old".into())
+ .await
+ .unwrap()
+ .is_none()
+ );
+}
+
#[tokio::test]
async fn delete_workspace_reject_policy_aborts_before_db_or_disk_destruction() {
let app = Router::new().route(
diff --git a/crates/ai-memory-mcp/tests/admin_phase3.rs b/crates/ai-memory-mcp/tests/admin_phase3.rs
index a631ded1..c6d150e3 100644
--- a/crates/ai-memory-mcp/tests/admin_phase3.rs
+++ b/crates/ai-memory-mcp/tests/admin_phase3.rs
@@ -54,7 +54,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
diff --git a/crates/ai-memory-mcp/tests/admin_purge.rs b/crates/ai-memory-mcp/tests/admin_purge.rs
index cf8f714f..3ef2a230 100644
--- a/crates/ai-memory-mcp/tests/admin_purge.rs
+++ b/crates/ai-memory-mcp/tests/admin_purge.rs
@@ -45,7 +45,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
db_path,
};
(state, store)
@@ -353,7 +353,7 @@ async fn purge_project_rejecting_admission_leaves_source_intact() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
let (ws, _keep, doomed) = seed_two_projects(&store, &state.wiki).await;
@@ -454,7 +454,7 @@ async fn purge_project_idempotent_second_call_is_404() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
seed_two_projects(&store, &state_a.wiki).await;
diff --git a/crates/ai-memory-mcp/tests/admin_read_page.rs b/crates/ai-memory-mcp/tests/admin_read_page.rs
index 23fb4604..a94e6ffd 100644
--- a/crates/ai-memory-mcp/tests/admin_read_page.rs
+++ b/crates/ai-memory-mcp/tests/admin_read_page.rs
@@ -33,7 +33,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
diff --git a/crates/ai-memory-mcp/tests/admin_rename.rs b/crates/ai-memory-mcp/tests/admin_rename.rs
index 9a67a8ea..fbd7342b 100644
--- a/crates/ai-memory-mcp/tests/admin_rename.rs
+++ b/crates/ai-memory-mcp/tests/admin_rename.rs
@@ -39,7 +39,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
@@ -327,7 +327,7 @@ async fn rename_project_pages_still_searchable() {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
let rename_resp = post(
@@ -399,7 +399,7 @@ async fn rename_project_after_purge_returns_404_not_silent_200() {
bootstrap_lock: state.bootstrap_lock.clone(),
token_pepper: None,
active_project: state.active_project.clone(),
- on_project_moved: None,
+ scope_invalidator: None,
};
let purge_resp = post(
purge_state,
diff --git a/crates/ai-memory-mcp/tests/admin_status_search.rs b/crates/ai-memory-mcp/tests/admin_status_search.rs
index 9287a28a..6a7cf28f 100644
--- a/crates/ai-memory-mcp/tests/admin_status_search.rs
+++ b/crates/ai-memory-mcp/tests/admin_status_search.rs
@@ -34,7 +34,7 @@ async fn make_admin_state(tmp: &TempDir) -> (AdminState, Store) {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
};
(state, store)
}
diff --git a/crates/ai-memory-mcp/tests/admin_write_page.rs b/crates/ai-memory-mcp/tests/admin_write_page.rs
index 8685fa5b..0c2b0375 100644
--- a/crates/ai-memory-mcp/tests/admin_write_page.rs
+++ b/crates/ai-memory-mcp/tests/admin_write_page.rs
@@ -34,7 +34,7 @@ async fn make_state(tmp: &TempDir) -> AdminState {
bootstrap_lock: std::sync::Arc::new(tokio::sync::Mutex::new(())),
token_pepper: None,
active_project: ai_memory_core::ActiveProject::new(),
- on_project_moved: None,
+ scope_invalidator: None,
}
}
diff --git a/docs/lifecycle-ops.md b/docs/lifecycle-ops.md
index 9e912276..62d5462a 100644
--- a/docs/lifecycle-ops.md
+++ b/docs/lifecycle-ops.md
@@ -140,10 +140,18 @@ refreshes `_meta.md` scope manifests with `Wiki::backfill_scope_manifests()` and
returns `manifests_refreshed` plus a post-rename checkpoint when the wiki tree
changed.
+If manifest refresh fails after the SQLite rename has committed, the rename
+still returns `200 OK` with `manifests_refreshed: 0` and a `manifest_warning`
+string instead of reporting a misleading 500. The DB rename is authoritative at
+that point; operators can rerun a manifest refresh or restore from the emitted
+checkpoint if they need to repair `_meta.md` drift.
+
Failure modes:
- **Source `from` not found** → 404.
- **`to` name already exists or is invalid** → 422.
+- **Manifest refresh failed after commit** → 200 with `manifest_warning` and
+ committed DB rename.
### `/admin/delete-workspace`