Skip to content

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

Rust

test: five adversarial security-boundary regressions across handoff, page-sharing, message, and lifecycle-guard invariants

AkitaOnRailse297f9d3b6e4
diff --git a/crates/ai-memory-cli/src/process_guard.rs b/crates/ai-memory-cli/src/process_guard.rs
index 5cc49e0f..6301fc7b 100644
--- a/crates/ai-memory-cli/src/process_guard.rs
+++ b/crates/ai-memory-cli/src/process_guard.rs
@@ -17,6 +17,24 @@ pub const BIN_NAME: &str = "ai-memory";
/// process and any threads of it).
#[must_use]
pub fn sibling_processes() -> Vec<sysinfo::Pid> {
+ // Test injection: a comma-separated list of fake PIDs to report as alive
+ // siblings, bypassing both the real scan AND the `cfg!(test)` opt-out
+ // below. This is what lets the guard's REFUSAL path be exercised by an
+ // in-process test (reset / reindex / restore / uninstall --purge-data all
+ // call `sibling_processes()` directly, and `cfg!(test)` alone would
+ // otherwise force every in-process test onto the "no siblings" branch).
+ // Checked first, and not itself gated by `cfg!(test)`, matching the
+ // existing `AI_MEMORY_TEST_NO_PROCESS_GUARD` opt-out below: neither is
+ // reachable in a normal shipped run because neither is ever set outside
+ // a test harness's own env.
+ if let Ok(raw) = std::env::var("AI_MEMORY_TEST_FORCE_SIBLING_PIDS") {
+ return raw
+ .split(',')
+ .filter(|s| !s.trim().is_empty())
+ .filter_map(|s| s.trim().parse::<u32>().ok())
+ .map(sysinfo::Pid::from_u32)
+ .collect();
+ }
// Test opt-out. The destructive-command tests would otherwise flake
// non-deterministically: a dev box (and a parallel test run) almost always
// has some *other* `ai-memory` process alive, which the real scan rightly
diff --git a/crates/ai-memory-cli/tests/suite/removal.rs b/crates/ai-memory-cli/tests/suite/removal.rs
index 12c4f6d0..c2b0e4f7 100644
--- a/crates/ai-memory-cli/tests/suite/removal.rs
+++ b/crates/ai-memory-cli/tests/suite/removal.rs
@@ -943,9 +943,12 @@ fn uninstall_dry_run_previews_purge() {
}
}
-/// Best-effort, NOT in the default run (sysinfo reads the real process table;
-/// no injection seam). Spawns a real sibling `ai-memory` process and asserts
-/// `--purge-data` refuses up front, leaving the wiring intact. Run with:
+/// Best-effort, NOT in the default run (sysinfo reads the real process
+/// table). Spawns a REAL sibling `ai-memory` process — as opposed to the
+/// `AI_MEMORY_TEST_FORCE_SIBLING_PIDS` injection seam the tests below use —
+/// so the actual sysinfo scan itself stays covered, not just the refusal
+/// logic downstream of it. Asserts `--purge-data` refuses up front, leaving
+/// the wiring intact. Run with:
/// `cargo test -p ai-memory-cli --test removal -- --ignored`.
#[test]
#[ignore]
@@ -988,6 +991,273 @@ fn purge_data_refuses_when_sibling_alive() {
);
}
+// ----------------------------------------------------------------
+// Process-guard injection seam (`AI_MEMORY_TEST_FORCE_SIBLING_PIDS`).
+//
+// `process_guard::sibling_processes()` normally either does a real sysinfo
+// scan, or (only under `cfg!(test)` / `AI_MEMORY_TEST_NO_PROCESS_GUARD`)
+// short-circuits to "no siblings" — which made the guard's REFUSAL branch
+// untestable from an in-process test and left `purge_data_refuses_when_
+// sibling_alive` above `#[ignore]`d, needing a real spawned sibling. These
+// tests exercise the refusal deterministically via the injection seam,
+// against every direct-disk lifecycle command the guard protects: `reset`,
+// `restore`, `reindex`, and `uninstall --purge-data`.
+// ----------------------------------------------------------------
+
+/// `reset --confirm` refuses while a sibling is reported alive, and leaves
+/// the data dir completely untouched.
+#[test]
+fn reset_refuses_when_sibling_pid_is_injected() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+ for sub in ["wiki", "db", "raw"] {
+ std::fs::create_dir_all(data.path().join(sub)).unwrap();
+ std::fs::write(data.path().join(sub).join("f.txt"), b"x").unwrap();
+ }
+
+ let out = command_with_home(home.path())
+ .args(["reset", "--confirm"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "424242")
+ .output()
+ .unwrap();
+
+ assert!(
+ !out.status.success(),
+ "should refuse while a sibling is alive"
+ );
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ assert!(
+ stderr.contains("refusing to reset") && stderr.contains("424242"),
+ "stderr was: {stderr}"
+ );
+ for sub in ["wiki", "db", "raw"] {
+ assert!(
+ data.path().join(sub).join("f.txt").exists(),
+ "{sub}/f.txt must survive a refused reset"
+ );
+ }
+}
+
+/// The control: an explicitly EMPTY injected sibling list must not block a
+/// legitimate `reset --confirm`.
+#[test]
+fn reset_proceeds_when_injected_sibling_list_is_empty() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+ for sub in ["wiki", "db", "raw"] {
+ std::fs::create_dir_all(data.path().join(sub)).unwrap();
+ std::fs::write(data.path().join(sub).join("f.txt"), b"x").unwrap();
+ }
+
+ let out = command_with_home(home.path())
+ .args(["reset", "--confirm"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "")
+ .output()
+ .unwrap();
+
+ assert!(
+ out.status.success(),
+ "stderr: {}",
+ String::from_utf8_lossy(&out.stderr)
+ );
+ for sub in ["wiki", "db", "raw"] {
+ assert!(
+ !data.path().join(sub).join("f.txt").exists(),
+ "{sub} must be wiped once the guard reports no siblings"
+ );
+ }
+}
+
+/// `restore --from` refuses while a sibling is reported alive, before ever
+/// checking whether the source tarball exists.
+#[test]
+fn restore_refuses_when_sibling_pid_is_injected() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+
+ let out = command_with_home(home.path())
+ .args(["restore", "--from", "/does/not/exist.tar.gz"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "424242")
+ .output()
+ .unwrap();
+
+ assert!(
+ !out.status.success(),
+ "should refuse while a sibling is alive"
+ );
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ assert!(
+ stderr.contains("refusing to restore") && stderr.contains("424242"),
+ "stderr was: {stderr}"
+ );
+ assert!(
+ !stderr.contains("not found"),
+ "the guard must refuse BEFORE the missing-tarball check runs: {stderr}"
+ );
+}
+
+/// The control: an explicitly EMPTY injected sibling list lets `restore` past
+/// the guard — it then fails on the next check (missing tarball) instead of
+/// the busy message, proving the guard itself is not what stopped it.
+#[test]
+fn restore_proceeds_when_injected_sibling_list_is_empty() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+
+ let out = command_with_home(home.path())
+ .args(["restore", "--from", "/does/not/exist.tar.gz"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "")
+ .output()
+ .unwrap();
+
+ assert!(!out.status.success(), "still fails, but past the guard");
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ assert!(
+ stderr.contains("not found"),
+ "expected the missing-tarball error once no sibling is reported: {stderr}"
+ );
+ assert!(
+ !stderr.contains("refusing to restore"),
+ "stderr was: {stderr}"
+ );
+}
+
+/// `reindex` refuses while a sibling is reported alive, before ever opening
+/// the SQLite store.
+#[test]
+fn reindex_refuses_when_sibling_pid_is_injected() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+ std::fs::create_dir_all(data.path().join("wiki")).unwrap();
+
+ let out = command_with_home(home.path())
+ .args(["reindex"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "424242")
+ .output()
+ .unwrap();
+
+ assert!(
+ !out.status.success(),
+ "should refuse while a sibling is alive"
+ );
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ assert!(
+ stderr.contains("refusing to reindex") && stderr.contains("424242"),
+ "stderr was: {stderr}"
+ );
+ // Nothing should have been created; the guard runs before `Store::open`.
+ assert!(
+ !data.path().join("db").join("memory.sqlite").exists(),
+ "the guard must refuse before the store is opened/created"
+ );
+}
+
+/// The control: an explicitly EMPTY injected sibling list lets `reindex`
+/// proceed and actually rebuild the (empty) index.
+#[test]
+fn reindex_proceeds_when_injected_sibling_list_is_empty() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+ std::fs::create_dir_all(data.path().join("wiki")).unwrap();
+
+ let out = command_with_home(home.path())
+ .args(["reindex"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "")
+ .output()
+ .unwrap();
+
+ assert!(
+ out.status.success(),
+ "stderr: {}",
+ String::from_utf8_lossy(&out.stderr)
+ );
+ assert!(
+ data.path().join("db").join("memory.sqlite").exists(),
+ "reindex must have opened/created the store once no sibling is reported"
+ );
+}
+
+/// `uninstall --purge-data` refuses while a sibling is reported alive, and
+/// leaves the data dir untouched — the sibling of the ignored real-process
+/// test above, but deterministic and in the default run.
+#[test]
+fn uninstall_purge_data_refuses_when_sibling_pid_is_injected() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+ for sub in ["wiki", "db", "raw"] {
+ std::fs::create_dir_all(data.path().join(sub)).unwrap();
+ std::fs::write(data.path().join(sub).join("f.txt"), b"x").unwrap();
+ }
+
+ let out = command_with_home(home.path())
+ .args(["uninstall", "--apply", "--yes", "--purge-data"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "424242")
+ .output()
+ .unwrap();
+
+ assert!(
+ !out.status.success(),
+ "should refuse while a sibling is alive"
+ );
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ assert!(
+ stderr.contains("refusing to purge data") && stderr.contains("424242"),
+ "stderr was: {stderr}"
+ );
+ for sub in ["wiki", "db", "raw"] {
+ assert!(
+ data.path().join(sub).join("f.txt").exists(),
+ "{sub}/f.txt must survive a refused purge"
+ );
+ }
+}
+
+/// The control: an explicitly EMPTY injected sibling list must not block a
+/// legitimate `uninstall --apply --yes --purge-data`.
+#[test]
+fn uninstall_purge_data_proceeds_when_injected_sibling_list_is_empty() {
+ let _guard = cli_test_lock();
+ let home = tempfile::tempdir().unwrap();
+ let data = tempfile::tempdir().unwrap();
+ for sub in ["wiki", "db", "raw"] {
+ std::fs::create_dir_all(data.path().join(sub)).unwrap();
+ std::fs::write(data.path().join(sub).join("f.txt"), b"x").unwrap();
+ }
+
+ let out = command_with_home(home.path())
+ .args(["uninstall", "--apply", "--yes", "--purge-data"])
+ .env("AI_MEMORY_DATA_DIR", data.path())
+ .env("AI_MEMORY_TEST_FORCE_SIBLING_PIDS", "")
+ .output()
+ .unwrap();
+
+ assert!(
+ out.status.success(),
+ "stderr: {}",
+ String::from_utf8_lossy(&out.stderr)
+ );
+ for sub in ["wiki", "db", "raw"] {
+ assert!(
+ !data.path().join(sub).join("f.txt").exists(),
+ "{sub} must be purged once the guard reports no siblings"
+ );
+ }
+}
+
#[test]
fn uninstall_devin_hooks_preserves_user_entries() {
let _guard = cli_test_lock();
diff --git a/crates/ai-memory-mcp/tests/suite/handoff_admission.rs b/crates/ai-memory-mcp/tests/suite/handoff_admission.rs
index aa9f056c..0a18d75e 100644
--- a/crates/ai-memory-mcp/tests/suite/handoff_admission.rs
+++ b/crates/ai-memory-mcp/tests/suite/handoff_admission.rs
@@ -431,3 +431,126 @@ async fn unauthorised_any_owner_cancel_reaches_no_webhook() {
"the refused cancel must not have discarded the baton",
);
}
+
+/// The sibling of `unauthorised_any_owner_cancel_reaches_no_webhook` for the
+/// accept path: a non-admin proxied caller ("alice") asking to accept a
+/// baton owned by "bob" via `any_owner: true` must be refused by
+/// `require_admin_capability`, must not reach the admission chain, and must
+/// NOT have claimed the handoff — accept is a compare-and-set consume, so a
+/// silently-successful bypass here would hand a stranger's session state to
+/// anyone who could reach the tool. An admin (root) doing the exact same
+/// call is the control: `any_owner` recovery must still work for the
+/// operator it exists for.
+#[tokio::test]
+async fn unauthorised_any_owner_accept_reaches_no_webhook_and_does_not_claim() {
+ let (addr, calls) = recording_webhook_host().await;
+ let h = proxied_harness(guarded_chain(addr)).await;
+
+ // Inserted directly, as the cancel test does: going through the tool
+ // would put a legitimate `handoff_begin` in the recording, and what is
+ // under test is that the refused accept adds nothing to it.
+ let id = h
+ .store
+ .writer
+ .insert_handoff(ai_memory_core::NewHandoff {
+ workspace_id: h.ws,
+ project_id: h.proj,
+ from_session_id: None,
+ from_agent: ai_memory_core::AgentKind::ClaudeCode,
+ to_agent: None,
+ cwd: None,
+ summary: "bobs-baton".to_string(),
+ open_questions: Vec::new(),
+ next_steps: Vec::new(),
+ files_touched: Vec::new(),
+ owner_user: ai_memory_core::owner_stamp(
+ Some(&ai_memory_core::IdentityKey::User("bob".into())),
+ true,
+ ),
+ })
+ .await
+ .expect("insert handoff");
+
+ let response = call_tool_raw(
+ &h.router,
+ "memory_handoff_accept",
+ json!({
+ "workspace": "default",
+ "project": "scratch",
+ "handoff_id": id.to_string(),
+ "any_owner": true,
+ }),
+ &proxied_as("alice"),
+ )
+ .await;
+ // Asserted on the message, not merely the presence of an error: a
+ // rejection from the auth layer itself would also produce one, and would
+ // make this test pass without the capability gate ever running.
+ let message = response
+ .pointer("/error/message")
+ .and_then(|m| m.as_str())
+ .unwrap_or_else(|| panic!("a non-admin caller must be refused any_owner: {response}"));
+ assert!(
+ message.contains("admin"),
+ "expected the admin capability gate to refuse this, got: {message}",
+ );
+
+ settle().await;
+ assert!(
+ calls.lock().unwrap().is_empty(),
+ "an operation the caller was never permitted must reach no webhook: {:?}",
+ calls.lock().unwrap(),
+ );
+ assert_eq!(
+ h.store
+ .reader
+ .handoff_by_id(id)
+ .await
+ .expect("read back")
+ .expect("row still there")
+ .lifecycle
+ .state,
+ ai_memory_core::HandoffState::Open,
+ "the refused accept must not have claimed bob's baton",
+ );
+
+ // Control: an admin (root) CAN accept via `any_owner`, because the
+ // recovery path this gate exists for must still work for the operator it
+ // is meant for.
+ let accepted = call_tool_raw(
+ &h.router,
+ "memory_handoff_accept",
+ json!({
+ "workspace": "default",
+ "project": "scratch",
+ "handoff_id": id.to_string(),
+ "any_owner": true,
+ }),
+ &[("authorization", "Bearer the-root-token")],
+ )
+ .await;
+ assert!(
+ accepted.get("error").is_none(),
+ "root's any_owner accept must succeed: {accepted}",
+ );
+ let claimed_summary = accepted
+ .pointer("/result/content/0/text")
+ .and_then(|t| t.as_str())
+ .unwrap_or_else(|| panic!("missing tool text: {accepted}"));
+ assert!(
+ claimed_summary.contains("bobs-baton"),
+ "root's recovery accept must actually claim bob's baton: {claimed_summary}",
+ );
+ assert_eq!(
+ h.store
+ .reader
+ .handoff_by_id(id)
+ .await
+ .expect("read back")
+ .expect("row still there")
+ .lifecycle
+ .state,
+ ai_memory_core::HandoffState::Accepted,
+ "the admin's accept must have claimed the baton",
+ );
+}
diff --git a/crates/ai-memory-store/tests/suite/agent_messages.rs b/crates/ai-memory-store/tests/suite/agent_messages.rs
index d05f0842..1be6fddf 100644
--- a/crates/ai-memory-store/tests/suite/agent_messages.rs
+++ b/crates/ai-memory-store/tests/suite/agent_messages.rs
@@ -219,6 +219,77 @@ async fn recipient_cannot_cancel_the_senders_outbox() {
);
}
+/// The sibling of `recipient_cannot_cancel_the_senders_outbox` for the
+/// specific-id path: the existing test only exercises whole-outbox cancel
+/// (`specific_id: None`), which is scoped by `from_workspace_id`/
+/// `from_project_id` alone and would still refuse B even if the id-scoped
+/// branch dropped that guard. This targets B's exact knowledge of A's
+/// message id directly, so it can only pass if the id-scoped `UPDATE` also
+/// carries the sender-coordinate `AND from_workspace_id = ... AND
+/// from_project_id = ...` guard.
+#[tokio::test]
+async fn recipient_cannot_cancel_a_specific_message_by_id() {
+ let tmp = tempfile::tempdir().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let a = project(&store, "default", "project-a").await;
+ let b = project(&store, "default", "project-b").await;
+
+ let a_msg_id = store
+ .writer
+ .insert_message(message(a, b, "A's own message"))
+ .await
+ .unwrap();
+
+ // B knows the exact id (e.g. from its own inbox listing) but must not be
+ // able to cancel A's outbound message by targeting it directly.
+ let cancelled = store
+ .writer
+ .cancel_messages(b.0, b.1, Some(a_msg_id))
+ .await
+ .unwrap();
+ assert_eq!(
+ cancelled, 0,
+ "B cancelling A's message by exact id must not touch it"
+ );
+
+ let popped = store
+ .writer
+ .pop_message(claim(b), Some(a_msg_id))
+ .await
+ .unwrap();
+ assert_eq!(
+ popped
+ .expect("A's message must still be pending and poppable by B")
+ .body,
+ "A's own message"
+ );
+
+ // Control: A cancelling its OWN message by the same exact id succeeds.
+ let a_msg_id_2 = store
+ .writer
+ .insert_message(message(a, b, "A's second message"))
+ .await
+ .unwrap();
+ let cancelled_by_owner = store
+ .writer
+ .cancel_messages(a.0, a.1, Some(a_msg_id_2))
+ .await
+ .unwrap();
+ assert_eq!(
+ cancelled_by_owner, 1,
+ "A cancelling its own message by exact id must succeed"
+ );
+ assert!(
+ store
+ .writer
+ .pop_message(claim(b), Some(a_msg_id_2))
+ .await
+ .unwrap()
+ .is_none(),
+ "a cancelled message must not be delivered"
+ );
+}
+
/// Popping by an explicit id claims that specific message; FIFO otherwise.
#[tokio::test]
async fn pop_can_target_a_specific_message_id() {
@@ -257,6 +328,45 @@ async fn pop_can_target_a_specific_message_id() {
assert_eq!(remaining[0].body, "first");
}
+/// Two racing pops of the SAME pending message must not both claim it: the
+/// baton claim-once discipline this module's own doc comment promises. Both
+/// calls are dispatched together via `tokio::join!` so their `WriteCmd`s land
+/// on the single-writer actor back-to-back, exercising the real
+/// `state = 'pending'` guards in `pop_message_in_transaction` rather than
+/// relying on test-side sequencing to keep them apart.
+#[tokio::test]
+async fn concurrent_pops_of_one_message_deliver_it_exactly_once() {
+ let tmp = tempfile::tempdir().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let a = project(&store, "default", "project-a").await;
+ let b = project(&store, "default", "project-b").await;
+
+ let id = store
+ .writer
+ .insert_message(message(a, b, "only one winner"))
+ .await
+ .unwrap();
+
+ // Targeted by exact id (rather than `None`/FIFO) so the race exercises
+ // Guard 1 + Guard 2 in `pop_message_in_transaction` directly, instead of
+ // being pre-filtered by the FIFO candidate selection's own `state =
+ // 'pending'` clause before either guard runs.
+ let writer1 = store.writer.clone();
+ let writer2 = store.writer.clone();
+ let (r1, r2) = tokio::join!(
+ writer1.pop_message(claim(b), Some(id)),
+ writer2.pop_message(claim(b), Some(id)),
+ );
+ let r1 = r1.unwrap();
+ let r2 = r2.unwrap();
+
+ let winners = [&r1, &r2].into_iter().filter(|r| r.is_some()).count();
+ assert_eq!(
+ winners, 1,
+ "exactly one of two concurrent pops must claim the message: {r1:?} / {r2:?}",
+ );
+}
+
/// A full recipient inbox rejects new sends so a flood cannot exhaust the
/// recipient's context or storage.
#[tokio::test]
diff --git a/crates/ai-memory-store/tests/suite/multi_session.rs b/crates/ai-memory-store/tests/suite/multi_session.rs
index fce7ff76..2e707c73 100644
--- a/crates/ai-memory-store/tests/suite/multi_session.rs
+++ b/crates/ai-memory-store/tests/suite/multi_session.rs
@@ -18,7 +18,7 @@
use ai_memory_core::{
ActorContext, AgentKind, HandoffAcceptance, IdentityKey, NewHandoff, NewPage, NewSession,
- OwnerFilter, PagePath, ProjectId, SessionId, Tier, WorkspaceId, owner_stamp,
+ NewUser, OwnerFilter, PagePath, ProjectId, SessionId, Tier, UserRole, WorkspaceId, owner_stamp,
};
use ai_memory_store::Store;
@@ -130,6 +130,74 @@ async fn one_operators_page_is_readable_by_another_in_the_same_project() {
assert!(body.body.contains("We picked SQLite"));
}
+/// The stronger form of the collaboration guarantee: the existing sibling
+/// test writes with `author_id: None`, so it cannot tell an "authored pages
+/// are private" regression from a genuine bug — a filter keyed on the
+/// caller's identity would happily let a NULL-authored page through. This
+/// stamps a real, non-null `author_id` (operator A) and asserts operator B —
+/// a *different* identity, reading with no owner coordinate at all, exactly
+/// as `search_pages_for_project` and `page_body_by_ids` are shaped — still
+/// sees the page in full, through both the search path and the direct-body
+/// path. `pages.author_id` is attribution, never a read filter.
+#[tokio::test]
+async fn an_authored_page_is_readable_by_a_different_operator_via_search_and_body() {
+ let tmp = tempfile::tempdir().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let (ws, proj) = scope(&store).await;
+
+ let operator_a = store
+ .writer
+ .create_human_user(
+ NewUser {
+ username: "operator-a".into(),
+ name: Some("Operator A".into()),
+ email: Some("[email protected]".into()),
+ },
+ UserRole::User,
+ None,
+ false,
+ )
+ .await
+ .unwrap();
+
+ store
+ .writer
+ .upsert_page(NewPage {
+ author_id: Some(operator_a),
+ ..page(
+ ws,
+ proj,
+ "decisions/0002.md",
+ "Chose SQLite Again",
+ "We picked SQLite for the derived index, authored by operator A.",
+ )
+ })
+ .await
+ .unwrap();
+
+ // Operator B's read: no owner coordinate passed anywhere, because none of
+ // these signatures accept one — that absence IS the invariant.
+ let hits = store
+ .reader
+ .search_pages_for_project(ws, proj, "SQLite Again".to_string(), 10, None)
+ .await
+ .unwrap();
+ assert!(
+ hits.iter().any(|h| h.path.as_str() == "decisions/0002.md"),
+ "an authored page must be visible to a different operator's search; \
+ got {:?}",
+ hits.iter().map(|h| h.path.as_str()).collect::<Vec<_>>()
+ );
+
+ let body = store
+ .reader
+ .page_body_by_ids(ws, proj, "decisions/0002.md")
+ .await
+ .unwrap()
+ .expect("a different operator can still resolve the page by path");
+ assert!(body.body.contains("authored by operator A"));
+}
+
/// Two harnesses editing the same page keep both versions.
///
/// The latest write wins the `is_latest` flag — there is no merge, and none is