Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
fix(uninstall): check for live processes before stopping the service
AkitaOnRailsa5eec606ba3a
diff --git a/crates/ai-memory-cli/src/commands/uninstall.rs b/crates/ai-memory-cli/src/commands/uninstall.rsindex c8a43cff..7630f6f6 100644--- a/crates/ai-memory-cli/src/commands/uninstall.rs+++ b/crates/ai-memory-cli/src/commands/uninstall.rs@@ -783,27 +783,12 @@ pub fn run(config: &Config, args: UninstallArgs) -> anyhow::Result<()> {}}- // The service `setup` installed runs the server this uninstall is taking- // away; stop it first, so a purge below does not find it alive.- if let Some((manager, user_service::Removal::Removed(path))) = &service {- match user_service::remove(*manager, path, &user_service::SystemRunner)? {- user_service::Removal::Removed(path) => {- println!("✓ stopped and removed the user service {}", path.display());- }- other => print_service_plan(&other),- }- }-- // All-or-nothing: when we're going to purge data, refuse before touching- // the data if an ai-memory process is alive (matches reset's guard-at-top).- // Wiring-only uninstall stays unguarded — it edits agent config files the- // server never touches.- if args.purge_data {- let siblings = crate::process_guard::sibling_processes();- if !siblings.is_empty() {- anyhow::bail!(crate::process_guard::busy_message("purge data", &siblings));- }- }+ stop_service_guarding_purge(+ service.as_ref(),+ args.purge_data,+ &user_service::SystemRunner,+ crate::process_guard::sibling_processes,+ )?;// The current checkout's `.claude/settings.local.json` keeps its backup// under the data dir, as `install-hooks --scope project` does: a sibling@@ -911,6 +896,97 @@ fn setup_service(config: &Config) -> Option<(ServiceManager, user_service::RemovSome((manager, user_service::planned_removal(&path)))}+/// Stop the user service `setup` installed, refusing a data purge while any+/// other ai-memory process is alive.+///+/// All-or-nothing: the live-process check runs first, with the service's own+/// process left out because this uninstall is about to stop it, so a sibling+/// (a `run` session, a second server) refuses the purge before the service+/// is stopped or anything else is touched (matches reset's guard-at-top).+/// After the stop the check runs again without that exception: a service that+/// did not exit still holds the data. Wiring-only uninstall stays unguarded;+/// it edits agent config files the server never touches.+fn stop_service_guarding_purge(+ service: Option<&(ServiceManager, user_service::Removal)>,+ purge_data: bool,+ runner: &dyn user_service::CommandRunner,+ siblings: impl Fn() -> Vec<sysinfo::Pid>,+) -> Result<()> {+ let to_stop = match service {+ Some((manager, user_service::Removal::Removed(path))) => Some((*manager, path)),+ _ => None,+ };+ if purge_data {+ let service_pid = to_stop.and_then(|(manager, _)| service_main_pid(manager, runner));+ let others: Vec<sysinfo::Pid> = siblings()+ .into_iter()+ .filter(|pid| Some(pid.as_u32()) != service_pid)+ .collect();+ if !others.is_empty() {+ anyhow::bail!(crate::process_guard::busy_message("purge data", &others));+ }+ }+ if let Some((manager, path)) = to_stop {+ match user_service::remove(manager, path, runner)? {+ user_service::Removal::Removed(path) => {+ println!("✓ stopped and removed the user service {}", path.display());+ }+ other => print_service_plan(&other),+ }+ }+ if purge_data && to_stop.is_some() {+ let alive = siblings();+ if !alive.is_empty() {+ anyhow::bail!(crate::process_guard::busy_message("purge data", &alive));+ }+ }+ Ok(())+}++/// The running service's main process, as its manager reports it; `None`+/// when it is not running or the manager cannot say.+fn service_main_pid(+ manager: ServiceManager,+ runner: &dyn user_service::CommandRunner,+) -> Option<u32> {+ let pid = match manager {+ ServiceManager::SystemdUser => {+ let out = runner+ .run(+ "systemctl",+ &[+ "--user",+ "show",+ "--property=MainPID",+ "--value",+ user_service::SYSTEMD_UNIT_NAME,+ ],+ )+ .ok()+ .filter(|out| out.success)?;+ out.stdout.trim().parse::<u32>().ok()?+ }+ ServiceManager::Launchd => {+ // `launchctl list <label>` prints a dictionary with a+ // `"PID" = 123;` line while the job runs.+ let out = runner+ .run("launchctl", &["list", user_service::LAUNCHD_LABEL])+ .ok()+ .filter(|out| out.success)?;+ out.stdout.lines().find_map(|line| {+ line.trim()+ .strip_prefix("\"PID\" =")?+ .trim()+ .trim_end_matches(';')+ .trim()+ .parse::<u32>()+ .ok()+ })?+ }+ };+ (pid != 0).then_some(pid)+}+fn print_service_plan(removal: &user_service::Removal) {match removal {user_service::Removal::Absent => {}@@ -1634,6 +1710,137 @@ fn strip_mcp_toml(content: &str, name: Option<&str>, url: &str) -> Result<(Strinmod tests {use super::*;+ /// Answers `systemctl`/`launchctl` from a script and records each call.+ struct ServiceRunner {+ calls: std::cell::RefCell<Vec<String>>,+ main_pid: &'static str,+ }++ impl user_service::CommandRunner for ServiceRunner {+ fn run(&self, program: &str, args: &[&str]) -> Result<user_service::CommandOutcome> {+ let line = format!("{program} {}", args.join(" "));+ self.calls.borrow_mut().push(line.clone());+ let stdout = if line.contains("MainPID") {+ self.main_pid.to_owned()+ } else if line.starts_with("launchctl list") {+ format!(+ "{{\n\t\"Label\" = \"x\";\n\t\"PID\" = {};\n}};\n",+ self.main_pid+ )+ } else {+ String::new()+ };+ Ok(user_service::CommandOutcome {+ success: true,+ stdout,+ stderr: String::new(),+ })+ }+ }++ /// A unit `setup` rendered, written where `uninstall` finds it.+ fn setup_unit(root: &Path) -> (ServiceManager, user_service::Removal) {+ let manager = ServiceManager::SystemdUser;+ let unit = user_service::render(+ manager,+ &user_service::ServiceSpec {+ exe: root.join("bin").join("ai-memory"),+ data_dir: root.join("data"),+ config_path: root.join("config.toml"),+ home: root.to_path_buf(),+ xdg_config_home: None,+ },+ )+ .unwrap();+ std::fs::create_dir_all(unit.path.parent().unwrap()).unwrap();+ std::fs::write(&unit.path, &unit.contents).unwrap();+ (manager, user_service::planned_removal(&unit.path))+ }++ /// Adversarial: a live sibling (pid 777) refuses `--purge-data` BEFORE+ /// the service is stopped; the old order stopped it first and only then+ /// refused, leaving the user without a server and with nothing purged.+ /// Controls: the service's own process is not a sibling, and a purge+ /// with only that process alive stops the service and proceeds.+ #[cfg(unix)]+ #[test]+ fn purge_guard_refuses_a_live_sibling_before_stopping_the_service() {+ let root = tempfile::tempdir().unwrap();+ let service = setup_unit(root.path());+ assert!(matches!(service.1, user_service::Removal::Removed(_)));+ let runner = ServiceRunner {+ calls: std::cell::RefCell::default(),+ main_pid: "4242",+ };+ let pids = |raw: &[u32]| {+ raw.iter()+ .copied()+ .map(sysinfo::Pid::from_u32)+ .collect::<Vec<_>>()+ };++ let error =+ stop_service_guarding_purge(Some(&service), true, &runner, || pids(&[4242, 777]))+ .unwrap_err()+ .to_string();+ assert!(error.contains("777") && !error.contains("4242"), "{error}");+ assert!(+ !runner.calls.borrow().iter().any(|c| c.contains("disable")),+ "the service must still run: {:?}",+ runner.calls.borrow()+ );++ let alive = std::cell::RefCell::new(pids(&[4242]));+ stop_service_guarding_purge(Some(&service), true, &runner, || alive.replace(Vec::new()))+ .unwrap();+ assert!(+ runner+ .calls+ .borrow()+ .iter()+ .any(|c| c == "systemctl --user disable --now ai-memory.service")+ );+ }++ /// A service that did not exit after the stop still blocks the purge.+ #[cfg(unix)]+ #[test]+ fn purge_guard_rechecks_after_stopping_the_service() {+ let root = tempfile::tempdir().unwrap();+ let service = setup_unit(root.path());+ let runner = ServiceRunner {+ calls: std::cell::RefCell::default(),+ main_pid: "4242",+ };+ let error = stop_service_guarding_purge(Some(&service), true, &runner, || {+ vec![sysinfo::Pid::from_u32(4242)]+ })+ .unwrap_err()+ .to_string();+ assert!(error.contains("4242"), "{error}");+ }++ #[test]+ fn service_main_pid_reads_systemd_and_launchd() {+ let runner = |main_pid| ServiceRunner {+ calls: std::cell::RefCell::default(),+ main_pid,+ };+ assert_eq!(+ service_main_pid(ServiceManager::SystemdUser, &runner("4242\n")),+ Some(4242)+ );+ assert_eq!(+ service_main_pid(ServiceManager::SystemdUser, &runner("0\n")),+ None,+ "MainPID=0 means not running"+ );+ assert_eq!(+ service_main_pid(ServiceManager::Launchd, &runner("515")),+ Some(515)+ );+ }+/// Each installed plugin is removed through its own harness CLI, and one/// failure does not stop the next.#[test]diff --git a/docs/security-boundaries.md b/docs/security-boundaries.mdindex 777b2f58..3379cf8f 100644--- a/docs/security-boundaries.md+++ b/docs/security-boundaries.md@@ -65,7 +65,7 @@ means the boundary is not built yet.| 8e | Messaging: admission is the same for MCP and admin sends (#756) | `ai-memory-mcp/src/admin.rs` `handle_send_message` runs `Wiki::authorize_operation(.., AdmissionOp::MessageSend, ..)` at the recipient scope before `insert_message` (a refusal is 403 and stores nothing) and calls `notify_operation_observers` only after a successful commit; skipping webhooks needs `Capability::SkipAdmissionChain` (`skip_webhooks_for_admin_request`); the MCP path is `server.rs` `memory_message_send` | `admin.rs` `admin_message_send_reject_leaves_inbox_empty` (a rejecting webhook gets 403 and an empty inbox; fails with the admission call removed), controls `admin_message_send_observer_sees_commit_without_blocking_response` and `admin_message_send_full_inbox_does_not_notify_observer` | STRONG || 8f | Messaging: the web mailbox shows a restricted sender's name and a card's count only to a reader of that repository; it never consumes mail | `ai-memory-store/src/reader.rs` `list_inbox_with_senders` (`readable_repository_predicate("sp.id", viewer)` on the sender join, so the name is `NULL` for an unreadable sender) and `pending_inbox_counts` (`readable_repository_predicate("p.id", viewer)`); `ai-memory-web/src/routes/project.rs` `mailbox` is `list`-only, no pop/cancel route exists, and `mailbox_scope` matches the URL's exact project name (as `list_pages` does), so an alias never shows another project's mail | `routes.rs` `web_mailbox_hides_restricted_sender_names_and_cards` (a granted reader of the recipient is shown "a project you cannot read", the restricted sender's name and card never reach the grid, alice as the control; fails with either predicate removed), `web_mailbox_lists_only_this_projects_inbox_and_never_consumes_it` (sender and bystander pages show nothing of the recipient's mail, a POST is 405 and the message is still pending, the body is HTML-escaped), `web_mailbox_does_not_follow_a_project_alias` (a legacy key that resolves to `acme-api` shows none of its mail on `/w/default/api`; `acme-api` itself is the control) | STRONG || 9 | Scope resolution fail-closed | `ai-memory-store/src/scope.rs` no-create `lookup_existing_*`; identity-aware lookup accepts exact/canonical/v2-basename keys only when they deduplicate to one UUID; `ops.rs` `resolve_project_name_for_write` performs write authorization, optional name-only promotion, and audit in one writer transaction; create only via `create_explicit_scope`. The admin destructive project routes (`admin.rs` `resolve_target_for_admin`, used by `purge-project` / `rename-project` / `move-project`) accept a bare `project_id` as an alternative to the name: it is parsed to a UUID (400 on a malformed one), looked up **within the workspace the request named** via `ReaderPool::project_name_by_id` (404 when it names no row there, so a real id from another workspace is refused rather than resolved), and the two spellings are mutually exclusive (both or neither is a 400). `list-projects` carries the id in each row, and inherits the same row-level visibility filter as the name, so a restricted project leaks neither. `ProjectNameAmbiguous` refuses cross-forge/multi-candidate keys before mutation; its message names each holder and the key it matched by, but a restricted holder only as "a restricted project", because the lookup runs before any caller is authorized and the project list hides restricted names from callers without a grant; an audit failure after the name UPDATE rolls the transaction back. V76's derived-key indexes bound hot lookup to exact/canonical/legacy equality probes with at most four rows. Promoting public APIs return `ResolvedWriteScope` metadata (no untraced promotion API); MCP, admin, and managed-workstream write entry points make Wiki refresh/checkpoint the committed scope manifest after promotion and surface `manifest_warning` on success or any later operation failure; pure managed-run input validation precedes promotion. A managed run whose `project` is the name its checkout's git remote derives (`PrepareManagedRunRequest.repository_identity`, accepted only through `accept_wire_identity` and only when `path_style_name` equals the requested name) resolves through `resolve_project_by_identity_for_capture` — the identity holder, else the cwd-prefix project with `$HOME` excluded, claimed or renamed only for a writer — and then `authorize_scope_for(Write)` on the writer connection, so an identity can neither redirect a differently named run nor open, claim, or create a project the caller may not write; Project manifests persist the typed full identity/source and derived keys so clean reindex restores the same UUID and lookup behavior. Also `ai-memory-hooks/src/router.rs` `workspace_override_is_rescope` — the hook router's session-sticky gate resolves a marker's `workspace` override via this same no-create `lookup_existing_workspace` (never a hand-rolled lookup) and fails closed (treats it as a rescope, disqualifying sticky) on a different or unresolvable workspace; only an override that resolves to the session's OWN workspace is not a rescope (#976) | `scope.rs` `read_resolution_table_driven`, `multi_scope_resolution_deduplicates_and_validates`, `a_slashed_label_reaches_only_a_project_the_caller_may_use` (a `workspace/project` label passed as the project is authorized as the pair it names and creates nothing when refused; granted control), `a_slashed_write_resolves_its_own_pair_and_never_creates`, `an_existing_slashed_project_wins_over_the_split`, no-auto-create + `unscoped_write_with_unresolvable_coordinate_errors`; `dual_key_scope.rs` `page_write_failure_after_promotion_preserves_manifest_warning`, `handoff_failure_after_promotion_preserves_manifest_warning`; `workstream.rs` `managed_run_rejects_mutually_exclusive_selection_before_promotion`, `managed_run_downstream_failure_after_promotion_preserves_manifest_warning`; `identity_resolution.rs` `canonical_and_legacy_reads_resolve_one_legacy_row_without_renaming`, `authorized_write_promotes_in_place_and_preserves_dependents_and_legacy_lookup`, `read_only_user_cannot_promote_a_legacy_name`, `canonical_target_conflict_rolls_back_the_promotion`, `audit_failure_rolls_back_promotion_and_keeps_the_writer_alive`, `exact_name_that_is_another_forges_canonical_key_fails_closed`, `an_ambiguous_name_names_its_holders_but_not_a_restricted_one` (restricted holder unnamed; open holder named as the control), `concurrent_legacy_and_canonical_resolve_or_create_converge_on_one_uuid`; admin `admin_purge.rs` `purge_project_refuses_a_real_id_from_another_workspace` (a row that really exists in another workspace answers 404 from `default` and is left intact), admin_rename/admin_move `rename_project_refuses_a_real_id_from_another_workspace` / `move_project_refuses_a_real_id_from_another_workspace` (the same for rename and move, the foreign project keeps its name and workspace, with the same id accepted from its own workspace as the control), `purge_project_still_refuses_an_ambiguous_name_by_default` (a name held by two rows -- one via its `legacy_name` -- stays a 400 and purges nothing), `purge_project_by_id_reaches_the_twin_and_leaves_the_name_holder_intact` (legitimate control: the id reaches the row the name could not, and the name-holder survives with its name), and store `list_projects_with_stats_hides_a_restricted_projects_id_from_an_ungranted_viewer` (the id is absent exactly where the name is, for an ungranted viewer, and present for the operator -- bite-checked with the visibility filter removed); `project_coordinates.rs` `shared_candidate_query_deduplicates_before_bound_and_uses_only_indexes`; wiki `promoted_identity_round_trips_through_manifest_and_clean_reindex`, `old_project_manifest_without_identity_still_reindexes`, `reindex_rejects_project_coordinate_fields_that_do_not_match_identity`; admin `write_page_surfaces_manifest_failure_after_promotion`, `bootstrap_surfaces_manifest_failure_after_promotion`, `move_project_merge_surfaces_destination_promotion_manifest_warning`, `move_session_create_surfaces_destination_promotion_manifest_warning`; `multi_session.rs` `two_operators_promote_two_clone_keys_to_one_uuid_without_moving_active_pointers`; MCP `dual_key_scope.rs`; hooks `workstream.rs` `managed_run_by_remote_identity_claims_the_folder_named_project`, `managed_run_by_remote_identity_routes_past_an_identityless_twin` (name-only control is ambiguous), `managed_run_identity_never_redirects_another_project_name`, `managed_run_by_remote_identity_refuses_a_viewer_without_write` (outsider refused with no project created; granted member admitted as the control), `managed_run_identity_never_claims_a_restricted_legacy_project` (an outsider whose cwd sits in a restricted identity-less project is refused, the identity stays unrecorded and no twin appears; fails with either the writer's claim check or the route's write check removed; a granted member claims it as the control), `managed_run_identity_routing_stays_inside_the_requested_workspace`, `concurrent_identity_runs_on_a_legacy_project_converge_on_it` (invariant #16), `managed_run_promotion_refreshes_the_scope_manifest`, `managed_run_discloses_manifest_failure_after_committed_promotion` static read/write/authz/cross-workspace/cross-forge cases; `router.rs` `workspace_override_is_rescope_only_on_a_genuine_workspace_change` (same/different/unresolvable workspace cases), `sticky_routing_keeps_the_session_project_across_a_sibling_checkout` (regression: same workspace forwarded on every event + `project_src=repo-root` from a nested checkout stays sticky), `sticky_routing_still_rescopes_when_marker_names_a_different_workspace_mid_session` (opposite direction: a genuinely different workspace still rescopes even under `sticky`) | STRONG |-| 10 | Destructive-op live-process refusal + confirm flags (invariant #9); `purge-project`'s `dry_run` always wins over `confirm` so a preview request can never become destructive | `ai-memory-cli/src/commands/process_guard.rs` `sibling_processes` + confirm flags in `reset`/`restore`/`reindex`/`uninstall --purge-data`/`purge_project`; `admin.rs` `handle_purge_project` checks `req.dry_run` unconditionally, before `req.confirm`, mirroring `reclaim-ledger-versions` | `admin_purge.rs` confirm→400; `removal.rs` — injected live-sibling makes each destructive command bail before touching the data dir; `admin_purge.rs` `purge_project_confirm_true_and_dry_run_true_still_only_previews` — `{"confirm": true, "dry_run": true}` deletes nothing (the regression this row now also covers); `ops.rs` `purge_project_dry_run_changes_nothing` — every project-scoped row count, the `purged_scopes` tombstone, and the `audit_log` row are identical before/after a `PurgeMode::Preview` run; `ops.rs` `purge_project_counts_collateral_damage_in_another_project` and `admin_purge.rs` `purge_project_dry_run_and_confirmed_purge_both_report_collateral_damage_in_another_project` — a purge of project P collaterally deletes an observation, and orphans a handoff's session reference, in a *different* project Q (via `sessions` cascading out of P), and both the preview and the confirmed report count it | STRONG |+| 10 | Destructive-op live-process refusal + confirm flags (invariant #9); `purge-project`'s `dry_run` always wins over `confirm` so a preview request can never become destructive | `ai-memory-cli/src/commands/process_guard.rs` `sibling_processes` + confirm flags in `reset`/`restore`/`reindex`/`uninstall --purge-data`/`purge_project`; `admin.rs` `handle_purge_project` checks `req.dry_run` unconditionally, before `req.confirm`, mirroring `reclaim-ledger-versions` | `admin_purge.rs` confirm→400; `removal.rs` — injected live-sibling makes each destructive command bail before touching the data dir; `uninstall.rs` `purge_guard_refuses_a_live_sibling_before_stopping_the_service` — `uninstall --purge-data` checks for siblings (the `setup` service's own pid excepted) before it stops that service, and `purge_guard_rechecks_after_stopping_the_service` refuses when the stopped service is still alive; `admin_purge.rs` `purge_project_confirm_true_and_dry_run_true_still_only_previews` — `{"confirm": true, "dry_run": true}` deletes nothing (the regression this row now also covers); `ops.rs` `purge_project_dry_run_changes_nothing` — every project-scoped row count, the `purged_scopes` tombstone, and the `audit_log` row are identical before/after a `PurgeMode::Preview` run; `ops.rs` `purge_project_counts_collateral_damage_in_another_project` and `admin_purge.rs` `purge_project_dry_run_and_confirmed_purge_both_report_collateral_damage_in_another_project` — a purge of project P collaterally deletes an observation, and orphans a handoff's session reference, in a *different* project Q (via `sessions` cascading out of P), and both the preview and the confirmed report count it | STRONG || 10b | Session purge is scope+owner-bound (no cross-session/project over-delete); `purge-session`'s `dry_run` always wins over `confirm`, same as `purge-project` | `ai-memory-store/src/ops.rs` `purge_session` — selection scoped to `(workspace_id, project_id)` and keyed on this session's own `summary_page_id` **or** `path='sessions/<sid>.md'` + `json_extract(frontmatter_json,'$.session_id')=<sid>` (frontmatter owner, not the recursive latest-chain); `in_scope==0 → NotFound` fail-closed; the session's prompt `profile_candidates` (`source_ref = 'session:<sid>'`, a globally unique id) are deleted in whichever project the harvest filed them, matching the `observations` cascade they were harvested from; whole op in one transaction, and the tombstone it leaves is checked by `begin_session_row` and by the new-session arm of `admit_hook_session_event`; `move_project_workspace` re-stamps the `purged_sessions` tombstone with the rest of the project so it still matches after a move; `admin.rs` `handle_purge_session` checks `req.dry_run` unconditionally, before `req.confirm` | `ops.rs` `purge_session_leaves_a_sibling_session_in_the_same_project_intact`, `…refuses_a_session_from_another_project_and_deletes_nothing`, `…refuses_a_session_from_another_workspace`, `…does_not_delete_an_identically_pathed_page_in_another_project`, `…removes_older_summary_versions_without_deleting_prior_manual_page` (#862); `admin_purge.rs` `purge_session_confirm_true_and_dry_run_true_still_only_previews` — `{"confirm": true, "dry_run": true}` deletes nothing; `ops.rs` `purge_session_dry_run_changes_nothing` — every table a session purge touches, the `purged_sessions` tombstone, and the `audit_log` row are identical before/after a `PurgeMode::Preview` run; `ops.rs` `purge_session_counts_collateral_damage_in_another_project` and `admin_purge.rs` `purge_session_dry_run_and_confirmed_purge_both_report_collateral_damage_in_another_project` — purging session S collaterally deletes an observation, and orphans a handoff's session reference, in a *different* project (via `S`'s own id cascading), and both the preview and the confirmed report count it; `admin_purge.rs` `purge_session_dry_run_refuses_a_session_outside_its_named_scope` — the same session previewed under a different real project (same workspace) or a different real workspace whose project shares the name both 404 with no counts in the body, with the session's own scope as the 200 control; the `purged_sessions` tombstone holds against live hook ingest as well as `begin_session`: `ops.rs` `a_purged_session_is_not_recreated_by_hook_admission` (`admit_hook_session_event` refuses a purged session and writes nothing, with a sibling session and the same id in another project admitted as controls) and `router.rs` `async_processing_drops_events_of_a_purged_session` (the late delivery is a terminal `dropped_invalid`, not a failure the client retries) and `batch_drops_a_purged_session_then_commits_next_item` (the batch endpoint acknowledges it as `dropped_invalid` and commits the next item instead of stopping fail-fast); the user's own sentences the profile harvested from the session's prompts go with it: `ops.rs` `purge_session_deletes_the_profile_candidates_harvested_from_it` (including the candidate harvested from a prompt the session recorded in another project, whose observation the purge deletes through the cascade; a sibling session's candidates in both projects and a page candidate survive); `ops.rs` `a_purged_session_stays_purged_after_its_project_moves` (after `move-project`, `begin_session` for the purged id in the destination is refused with `SessionPurged`; a fresh session there is admitted as the control) | STRONG || 10c | Ledger reclaim is content-gated, not filename-gated (invariant #16) | `ai-memory-store/src/ops.rs` `reclaim_ledger_versions` — a candidate row must pass `ai_memory_core::log_ledger::body_opens_with_log_ledger` on its own `body`, and only `is_latest=0 AND superseded_at IS NULL` rows are eligible, so decay-owned rows stay with `forget-sweep`; confirm gate in `admin.rs` `handle_reclaim_ledger_versions` | `reclaim_ledger_versions.rs` `a_prose_page_wearing_the_ledger_name_keeps_its_whole_version_chain`, `an_ordinary_page_chain_in_another_project_is_untouched`, `a_decay_tombstone_stays_with_the_sweep_that_owns_it`; `admin_reclaim_ledger_versions.rs` `deleting_without_confirm_is_refused_and_changes_nothing` (with dry-run and confirmed controls) | STRONG || 10d | Workspace delete's own row counts are scope-bound to `workspace_id` (a workspace's *own* rows are never over- or under-counted by a sibling workspace's), its cross-workspace observation/handoff cascade is reported by both preview and confirm rather than prevented (same as `purge-project` one level down), the non-empty guard fails closed without `force`, and `delete-workspace`'s `dry_run` always wins | `ai-memory-store/src/ops.rs` `delete_workspace` — every direct count and the `DELETE FROM workspaces` itself are scoped by `workspace_id = ?1`; the two `collateral_*` counts are scoped by `workspace_id != ?1` so a row is counted as one or the other but never both; `projects_deleted > 0 && !force → WorkspaceNotEmpty` fail-closed, and a missing workspace is `NotFound`, both checked identically under `PurgeMode::Preview` and `PurgeMode::Commit`; whole op in one transaction; `admin.rs` `handle_delete_workspace` checks `req.dry_run` unconditionally, before building the confirmed path, mirroring `reclaim-ledger-versions`/`purge-project`; root-only gate is the shared `/admin/*` multi-user auth ladder, not a separate check | `admin_move.rs` `delete_workspace_dry_run_never_counts_a_different_workspaces_rows` — previewing workspace A counts only its own project/page/session/observation/handoff rows, not workspace B's (which holds two like-named projects and its own full row set), and a session living in B that stamps an observation directly into A is counted in A's own `observations_deleted`, never in `collateral_observations_deleted` (the two counts are mutually exclusive by construction); `admin_move.rs` `delete_workspace_force_true_and_dry_run_true_still_only_previews` — `{"force": true, "dry_run": true}` deletes nothing; `ops.rs` `delete_workspace_dry_run_changes_nothing` — every table's row count, including `workspaces` itself and the `purged_scopes` tombstone (the two tables a confirmed delete's own transaction writes to), is identical before/after a `PurgeMode::Preview` run; `ops.rs` `delete_workspace_dry_run_and_confirmed_delete_both_report_collateral_damage_in_another_workspace` and `admin_move.rs` of the same name — deleting workspace W collaterally deletes an observation, and orphans a handoff's session reference, in a *different* workspace (via `sessions` cascading out of W), and both the preview and the confirmed response count it identically — the cascade itself is reported, not blocked, by either; `admin_move.rs` `delete_workspace_dry_run_refuses_non_empty_without_force` / `delete_workspace_dry_run_nonexistent_workspace_returns_404` — same `409`/`404` a confirmed delete would give; `admin.rs` `multiuser_delete_workspace_dry_run_rejects_db_user_and_anonymous` — root reaches the preview handler (404 control), DB user gets 403, anonymous gets 401 | STRONG |