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.mdindex 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.0the 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 acceptinglater unrelated sources, returns non-contiguous acknowledgements for new spooldrains, bounds limiter key bytes, keys by actor+session with deterministicdiff --git a/crates/ai-memory-cli/src/commands/serve.rs b/crates/ai-memory-cli/src/commands/serve.rsindex 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::newdiff --git a/crates/ai-memory-core/src/active_project.rs b/crates/ai-memory-core/src/active_project.rsindex 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.rsindex 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.rsindex 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 ofdiff --git a/crates/ai-memory-mcp/src/admin.rs b/crates/ai-memory-mcp/src/admin.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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) -> (AdminStbootstrap_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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.mdindex 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()` andreturns `manifests_refreshed` plus a post-rename checkpoint when the wiki treechanged.+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`