scope-lock -> pod-registry

crates/pod/tests/pod_comm_tools_test.rs

@@ -15,7 +15,7 @@ use llm_worker::llm_client::types::{ContentPart, Item, Role};
 use llm_worker::tool::ToolOutput;
 use manifest::{Permission, ScopeRule};
 use pod::runtime::dir::{RuntimeDir, SpawnedPodRecord};
-use pod::runtime::scope_lock::{self, LockFileGuard};
+use pod::runtime::pod_registry::{self, LockFileGuard};
 use pod::spawn::comm_tools::{
     list_pods_tool, read_pod_output_tool, send_to_pod_tool, stop_pod_tool,
 };
@@ -86,7 +86,7 @@ async fn setup_registry() -> (TempDir, Arc<SpawnedPodRegistry>, Arc<RuntimeDir>)
 
 /// Register a fake spawned-child record pointing at a given socket
 /// path, with a trivial write-scope for `scope_path`. Does not touch
-/// scope.lock.
+/// pods.json.
 async fn register_child(
     registry: &SpawnedPodRegistry,
     name: &str,
@@ -334,14 +334,14 @@ async fn stop_pod_sends_shutdown_and_releases_scope() {
     unsafe {
         std::env::set_var("INSOMNIA_RUNTIME_DIR", tmp.path());
     }
-    let lock_path = tmp.path().join("scope.lock");
+    let lock_path = tmp.path().join("pods.json");
 
-    // Seed scope.lock with a top-level `spawner` allocation plus a
+    // Seed pods.json with a top-level `spawner` allocation plus a
     // delegated `child` allocation — mimics what SpawnPod would have
     // done so StopPod has something to release.
     {
         let mut g = LockFileGuard::open(&lock_path).unwrap();
-        scope_lock::register_pod(
+        pod_registry::register_pod(
             &mut g,
             "spawner".into(),
             std::process::id(),
@@ -354,7 +354,7 @@ async fn stop_pod_sends_shutdown_and_releases_scope() {
             session_store::new_session_id(),
         )
         .unwrap();
-        scope_lock::delegate_scope(
+        pod_registry::delegate_scope(
             &mut g,
             "spawner",
             "child".into(),

crates/pod/tests/pod_events_test.rs

@@ -11,7 +11,7 @@ use std::time::Duration;
 
 use pod::ipc::event::{apply_event_side_effects, fire_and_forget, render_event};
 use pod::runtime::dir::{RuntimeDir, SpawnedPodRecord};
-use pod::runtime::scope_lock::{self, LockFileGuard};
+use pod::runtime::pod_registry::{self, LockFileGuard};
 use pod::spawn::registry::SpawnedPodRegistry;
 use protocol::stream::JsonLineReader;
 use protocol::{Method, Permission, PodEvent, ScopeRule};
@@ -62,8 +62,8 @@ impl Drop for EnvGuard {
     }
 }
 
-/// Point `INSOMNIA_RUNTIME_DIR` at `dir`. The scope-lock then lives at
-/// `<dir>/scope.lock` and Pod runtime sub-dirs at `<dir>/{pod_name}/`.
+/// Point `INSOMNIA_RUNTIME_DIR` at `dir`. The pod-registry then lives at
+/// `<dir>/pods.json` and Pod runtime sub-dirs at `<dir>/{pod_name}/`.
 fn set_runtime_dir(dir: &std::path::Path) {
     unsafe {
         std::env::set_var("INSOMNIA_RUNTIME_DIR", dir);
@@ -348,12 +348,12 @@ async fn apply_turn_ended_and_errored_are_system_noops() {
 async fn shutdown_releases_scope_allocation_when_present() {
     let _env = EnvGuard::acquire();
     let scope_dir = TempDir::new().unwrap();
-    let lock_path = scope_dir.path().join("scope.lock");
+    let lock_path = scope_dir.path().join("pods.json");
     set_runtime_dir(scope_dir.path());
 
     // Install a top-level allocation for "kid" so ShutDown has
     // something to release.
-    let guard = scope_lock::install_top_level(
+    let guard = pod_registry::install_top_level(
         "kid".into(),
         std::process::id(),
         "/tmp/kid.sock".into(),

crates/pod/tests/restore_test.rs

@@ -2,7 +2,7 @@
 //! validation paths.
 //!
 //! These cases all return before `prepare_pod_common` runs, so they
-//! do not need a real LLM client or scope-lock environment — only the
+//! do not need a real LLM client or pod-registry environment — only the
 //! session store needs to be present.
 
 use std::sync::{LazyLock, Mutex};

crates/pod/tests/spawn_pod_test.rs

@@ -1,6 +1,6 @@
 //! Integration tests for the `SpawnPod` tool.
 //!
-//! These tests exercise the tool's scope-lock delegation, subprocess
+//! These tests exercise the tool's pod-registry delegation, subprocess
 //! launch, socket handoff, and `spawned_pods.json` write without relying
 //! on the real `pod` binary. `INSOMNIA_POD_COMMAND` is pointed at
 //! `/bin/true` (which exits immediately) while a test-owned Unix
@@ -13,7 +13,7 @@ use std::sync::{LazyLock, Mutex};
 use llm_worker::tool::{ToolError, ToolOutput};
 use manifest::{AuthRef, ModelManifest, Permission, SchemeKind, ScopeRule};
 use pod::runtime::dir::{RuntimeDir, SpawnedPodRecord};
-use pod::runtime::scope_lock::{self, LockFileGuard};
+use pod::runtime::pod_registry::{self, LockFileGuard};
 use pod::spawn::registry::SpawnedPodRegistry;
 use pod::spawn::tool::spawn_pod_tool;
 use protocol::Method;
@@ -40,7 +40,7 @@ impl EnvGuard {
 }
 
 /// Set up a tempdir, point `INSOMNIA_RUNTIME_DIR` at it (so
-/// `scope.lock` and per-Pod runtime subdirs both land in the
+/// `pods.json` and per-Pod runtime subdirs both land in the
 /// sandbox), and install a live top-level "spawner" allocation so the
 /// tool has something to delegate from. Returns the tempdir (keeps it
 /// alive for the test's lifetime), runtime base, spawner socket, and
@@ -64,7 +64,7 @@ async fn setup_spawner(
         .unwrap();
     let spawner_socket = spawner_rd.socket_path();
 
-    let _guard = scope_lock::install_top_level(
+    let _guard = pod_registry::install_top_level(
         spawner_name.into(),
         std::process::id(),
         spawner_socket.clone(),
@@ -207,8 +207,8 @@ async fn spawn_pod_delegates_scope_and_sends_run() {
         other => panic!("expected Run, got {other:?}"),
     }
 
-    // Verify scope_lock has the child allocation under `root`.
-    let lock_path = scope_lock::default_lock_path().unwrap();
+    // Verify pod_registry has the child allocation under `root`.
+    let lock_path = pod_registry::default_registry_path().unwrap();
     let guard = LockFileGuard::open(&lock_path).unwrap();
     let child = guard
         .data()
@@ -273,7 +273,7 @@ async fn spawn_pod_rejects_scope_outside_spawner() {
     }
 
     // The spawner's allocation is unchanged; no "child" appeared.
-    let lock_path = scope_lock::default_lock_path().unwrap();
+    let lock_path = pod_registry::default_registry_path().unwrap();
     let guard = LockFileGuard::open(&lock_path).unwrap();
     assert!(guard.data().find("child").is_none());
 
@@ -334,7 +334,7 @@ async fn spawn_pod_rolls_back_reservation_when_socket_never_appears() {
     }
 
     // Rollback assertion: the reserved "ghost" allocation is gone.
-    let lock_path = scope_lock::default_lock_path().unwrap();
+    let lock_path = pod_registry::default_registry_path().unwrap();
     let guard = LockFileGuard::open(&lock_path).unwrap();
     assert!(
         guard.data().find("ghost").is_none(),