diff --git a/crates/mvm-agentd/src/vsock/api.rs b/crates/mvm-agentd/src/vsock/api.rs
index 857eae379a..5746b98265 100644
--- a/crates/mvm-agentd/src/vsock/api.rs
+++ b/crates/mvm-agentd/src/vsock/api.rs
@@ -357,7 +357,7 @@ pub fn query_fs_diff_at(vsock_uds_path: &str) -> Result<Vec<FsChange>> {
 
 /// Query filesystem diff on an already-connected stream. Backend-agnostic
 /// entry point for `mvmctl diff` — the stream comes from
-/// `mvm_runtime::vsock_transport::for_vm(name)` so the verb works against any VMM.
+/// `mvm_vmm::vsock_transport::for_vm(name)` so the verb works against any VMM.
 /// `FsDiff` is part of the filesystem RPC surface, so this drives
 /// the hello prelude requiring `FilesystemRpc` exactly like
 /// [`send_fs_request_on`] — the dir-based wrappers used to skip the hello,
@@ -409,7 +409,7 @@ pub fn send_proc_request(instance_dir: &str, req: GuestRequest) -> Result<ProcRe
 
 /// Dispatch a non-streaming process-control verb on an already-connected
 /// stream and return the `ProcResult`. The backend-agnostic entry point:
-/// the host CLI obtains the stream from `mvm_runtime::vsock_transport::for_vm(name)`
+/// the host CLI obtains the stream from `mvm_vmm::vsock_transport::for_vm(name)`
 /// so `mvmctl proc` works regardless of which VMM launched the VM.
 /// `send_proc_request` is the dir-based wrapper over this.
 pub fn send_proc_request_on(stream: &mut UnixStream, req: GuestRequest) -> Result<ProcResult> {
@@ -449,7 +449,7 @@ pub fn send_proc_wait<F: FnMut(&ProcWaitEvent)>(
 
 /// Stream `ProcWait` events on an already-connected stream. Backend-agnostic
 /// entry point for `mvmctl proc wait` — the stream comes from
-/// `mvm_runtime::vsock_transport::for_vm(name)` so the verb works against any VMM.
+/// `mvm_vmm::vsock_transport::for_vm(name)` so the verb works against any VMM.
 /// Mirrors the host shape of [`send_run_entrypoint`].
 pub fn send_proc_wait_on<F: FnMut(&ProcWaitEvent)>(
     stream: &mut UnixStream,
@@ -502,7 +502,7 @@ pub fn send_fs_request(instance_dir: &str, req: GuestRequest) -> Result<FsResult
 
 /// Dispatch a single FS RPC on an already-connected stream and return the
 /// `FsResult`. The backend-agnostic entry point: the host CLI obtains the
-/// stream from `mvm_runtime::vsock_transport::for_vm(name)` (which resolves the
+/// stream from `mvm_vmm::vsock_transport::for_vm(name)` (which resolves the
 /// right socket per backend — Firecracker's `v.sock`, or the per-port UNIX
 /// socket libkrun/QEMU expose), so `fs`/`cp` work regardless of which VMM
 /// launched the VM. `send_fs_request` is the dir-based wrapper
diff --git a/crates/mvm-build/src/builder_vm_runtime/image_lock.rs b/crates/mvm-build/src/builder_vm_runtime/image_lock.rs
index 56a63ef828..150888dad0 100644
--- a/crates/mvm-build/src/builder_vm_runtime/image_lock.rs
+++ b/crates/mvm-build/src/builder_vm_runtime/image_lock.rs
@@ -797,8 +797,8 @@ pub fn hold_image_lock(lock_path: &Path, wait: LockWait) -> Result<HeldImageLock
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_support::isolated_lock_probe;
     use crate::volume_image::{VolumeImageLock, ensure_persistent_volume_image};
+    use mvm_core::util::test_env::isolated_lock_probe;
 
     // -----------------------------------------------------------------
     // The cache dir is a &Path argument, so each test passes a fresh TempDir
diff --git a/crates/mvm-build/src/lib.rs b/crates/mvm-build/src/lib.rs
index 20eae02444..10374a6db4 100644
--- a/crates/mvm-build/src/lib.rs
+++ b/crates/mvm-build/src/lib.rs
@@ -20,9 +20,6 @@ pub mod source_closure;
 mod source_copy;
 pub mod workspace_graph;
 
-#[cfg(all(test, unix))]
-mod test_support;
-
 /// Portable image-contract verification; acquisition requires a Unix host.
 #[cfg(not(unix))]
 pub mod published_image_set {
diff --git a/crates/mvm-build/src/run_image.rs b/crates/mvm-build/src/run_image.rs
index bc59706064..c538c4f15a 100644
--- a/crates/mvm-build/src/run_image.rs
+++ b/crates/mvm-build/src/run_image.rs
@@ -1096,7 +1096,7 @@ pub fn resolve_guest_runtime_identity(cache_root: &Path) -> Result<String> {
 mod tests {
     use super::*;
     #[cfg(unix)]
-    use crate::test_support::isolated_lock_probe;
+    use mvm_core::util::test_env::isolated_lock_probe;
 
     #[test]
     fn pure_sealed_materialization_keeps_its_content_bound_seal() {
diff --git a/crates/mvm-build/src/test_support.rs b/crates/mvm-build/src/test_support.rs
deleted file mode 100644
index 2625c648d3..0000000000
--- a/crates/mvm-build/src/test_support.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Process isolation for tests that require control of descriptor lifetimes.
-
-pub(crate) use mvm_core::util::test_env::isolated_lock_probe;
diff --git a/crates/mvm-build/src/volume_image.rs b/crates/mvm-build/src/volume_image.rs
index 91bf465e76..9797113864 100644
--- a/crates/mvm-build/src/volume_image.rs
+++ b/crates/mvm-build/src/volume_image.rs
@@ -291,7 +291,7 @@ mod tests {
     use std::path::Path;
 
     use super::*;
-    use crate::test_support::isolated_lock_probe;
+    use mvm_core::util::test_env::isolated_lock_probe;
 
     const SIZE: u64 = 16 * 1024 * 1024;
 
diff --git a/crates/mvm-cli/examples/agent_invoke.rs b/crates/mvm-cli/examples/agent_invoke.rs
index 04ad989e78..2b9cb427d7 100644
--- a/crates/mvm-cli/examples/agent_invoke.rs
+++ b/crates/mvm-cli/examples/agent_invoke.rs
@@ -20,7 +20,7 @@ fn main() -> anyhow::Result<()> {
     // string into valid JSON for ordinary names.
     let payload = format!("[[{name:?}], {{}}]").into_bytes();
 
-    let transport = mvm_runtime::vsock_transport::for_vm(&vm)?;
+    let transport = mvm_vmm::vsock_transport::for_vm(&vm)?;
     let mut stream = transport.connect(mvm_agentd::vsock::GUEST_AGENT_PORT)?;
 
     let stdout = RefCell::new(Vec::<u8>::new());
diff --git a/crates/mvm-cli/examples/agent_ping.rs b/crates/mvm-cli/examples/agent_ping.rs
index f536472654..7092844084 100644
--- a/crates/mvm-cli/examples/agent_ping.rs
+++ b/crates/mvm-cli/examples/agent_ping.rs
@@ -8,7 +8,7 @@ fn main() -> anyhow::Result<()> {
     let vm = std::env::args()
         .nth(1)
         .ok_or_else(|| anyhow::anyhow!("usage: agent_ping <vm-name>"))?;
-    let transport = mvm_runtime::vsock_transport::for_vm(&vm)?;
+    let transport = mvm_vmm::vsock_transport::for_vm(&vm)?;
     let mut stream = transport.connect(mvm_agentd::vsock::GUEST_AGENT_PORT)?;
     let ack = mvm_agentd::vsock::negotiate_protocol(
         &mut stream,
diff --git a/crates/mvm-cli/src/commands/agent_session.rs b/crates/mvm-cli/src/commands/agent_session.rs
index f1cc0cce4d..cde4bf3668 100644
--- a/crates/mvm-cli/src/commands/agent_session.rs
+++ b/crates/mvm-cli/src/commands/agent_session.rs
@@ -445,7 +445,7 @@ fn renew_audit_extras(record: &AgentSessionRecord) -> Vec<(String, String)> {
 /// exactly as a park is.
 fn record_renew_in_chain(
     record: &AgentSessionRecord,
-    emitter: &super::vm::audit_chain::AuditEmitter,
+    emitter: &mvm_client::audit::chain::emitter::AuditEmitter,
 ) -> Result<()> {
     let plan = member_plan(record)?;
     emitter.emit_session_renewed(&plan, renew_audit_extras(record))
@@ -588,7 +588,7 @@ fn park_audit_extras(record: &AgentSessionRecord) -> Vec<(String, String)> {
 /// reported rather than recorded under a plan it never ran.
 fn record_park_in_chain(
     record: &AgentSessionRecord,
-    emitter: &super::vm::audit_chain::AuditEmitter,
+    emitter: &mvm_client::audit::chain::emitter::AuditEmitter,
 ) -> Result<()> {
     let plan = member_plan(record)?;
     emitter.emit_session_parked(&plan, park_audit_extras(record))
@@ -607,10 +607,10 @@ fn member_plan(record: &AgentSessionRecord) -> Result<mvm_core::plan::ExecutionP
 }
 
 /// The host's chain-signed audit emitter, under the host signer.
-fn host_audit_emitter() -> Result<super::vm::audit_chain::AuditEmitter> {
-    let signer = super::vm::host_signer::load_or_init()
+fn host_audit_emitter() -> Result<mvm_client::audit::chain::emitter::AuditEmitter> {
+    let signer = mvm_client::host_keypair::load_or_init()
         .context("loading the host signer to sign the session entry")?;
-    super::vm::audit_chain::AuditEmitter::new(signer.signing)
+    mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .context("opening the audit chain to record the session transition")
 }
 
@@ -789,9 +789,9 @@ fn resume_boot_record(
     // The session's own state dir, named for the session, so the staged resume
     // point sits where every other per-VM artifact for that name does.
     let state_dir = mvm_core::config::vm_state_dir(inputs.id.as_str());
-    let signer = super::vm::host_signer::load_or_init()
+    let signer = mvm_client::host_keypair::load_or_init()
         .context("loading the host signer to sign the resume entry")?;
-    let emitter = super::vm::audit_chain::AuditEmitter::new(signer.signing)
+    let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .context("opening the audit chain to record the resume")?;
     let resume = inputs.request();
     let request = ResumeBootLocalRequest::builder()
@@ -1896,7 +1896,7 @@ mod tests {
     struct ChainedHost {
         _env: mvm_core::util::test_env::TestEnv,
         home: tempfile::TempDir,
-        emitter: super::super::vm::audit_chain::AuditEmitter,
+        emitter: mvm_client::audit::chain::emitter::AuditEmitter,
     }
 
     impl ChainedHost {
@@ -1909,7 +1909,7 @@ mod tests {
                 &mvm_core::plan::signing::test_support::sample_plan(),
             )
             .unwrap();
-            let emitter = super::super::vm::audit_chain::AuditEmitter::with_dir(
+            let emitter = mvm_client::audit::chain::emitter::AuditEmitter::with_dir(
                 ed25519_dalek::SigningKey::from_bytes(&[7u8; 32]),
                 &home.path().join("audit"),
             )
diff --git a/crates/mvm-cli/src/commands/build/kernel.rs b/crates/mvm-cli/src/commands/build/kernel.rs
index 1ed3a8e6fe..72eb1cbc84 100644
--- a/crates/mvm-cli/src/commands/build/kernel.rs
+++ b/crates/mvm-cli/src/commands/build/kernel.rs
@@ -223,8 +223,8 @@ fn run_boot_check(
     arch: &str,
 ) -> Result<()> {
     use crate::commands::env::builder_vm::KernelVariant;
-    use crate::commands::shared::wait_for_guest_agent;
     use crate::ui;
+    use mvm_client::readiness::wait_for_guest_agent;
 
     if !variants.iter().any(|(v, _)| *v == KernelVariant::Workload) {
         ui::warn(
diff --git a/crates/mvm-cli/src/commands/cmd_audit.rs b/crates/mvm-cli/src/commands/cmd_audit.rs
index 42f7cbbe89..5370041f6e 100644
--- a/crates/mvm-cli/src/commands/cmd_audit.rs
+++ b/crates/mvm-cli/src/commands/cmd_audit.rs
@@ -17,7 +17,7 @@
 //! half), the wrap logs a `tracing::warn` and the command runs
 //! without cmd-level audit. Audit emits themselves are also
 //! best-effort — a chain-signer failure does NOT fail the command,
-//! same posture as `mvm_cli::commands::vm::audit_chain::AuditEmitter`
+//! same posture as `mvm_client::audit::chain::emitter::AuditEmitter`
 //! and the secret command's audit wiring.
 //!
 //! ## Why a separate module
@@ -35,8 +35,8 @@ use mvm_core::plan::TenantId;
 
 use super::Commands;
 use super::machine;
-use super::vm::audit_chain::default_audit_dir;
-use super::vm::host_signer;
+use mvm_client::audit::chain::emitter::default_audit_dir;
+use mvm_client::host_keypair;
 
 /// Owns the command recorder and keeps its concrete file signer available to
 /// launch audit emitters for the duration of dispatch.
@@ -62,7 +62,7 @@ impl CommandAudit {
 /// `EventCategory::Cmd` for both `cmd.<verb>` and `cmd.tool.<verb>`
 /// events), so one builder serves every consumer.
 pub(crate) fn build_cmd_recorder() -> Option<CommandAudit> {
-    let signer = match host_signer::load_or_init() {
+    let signer = match host_keypair::load_or_init() {
         Ok(s) => s,
         Err(e) => {
             tracing::warn!(
diff --git a/crates/mvm-cli/src/commands/deps/live_capture.rs b/crates/mvm-cli/src/commands/deps/live_capture.rs
index d9ef511509..8006941cf0 100644
--- a/crates/mvm-cli/src/commands/deps/live_capture.rs
+++ b/crates/mvm-cli/src/commands/deps/live_capture.rs
@@ -324,7 +324,7 @@ fn list_guest(vm: &str, path: &str) -> Result<Vec<mvm_agentd::vsock::FsEntry>> {
         path: path.to_string(),
         follow_symlinks: false,
     };
-    crate::commands::shared::emit_vsock_rpc_audit(vm, &request);
+    mvm_client::guest::emit_vsock_rpc_audit(vm, &request);
     match crate::commands::vm::fs::fs_request(vm, request)? {
         FsResult::List { entries, truncated } if !truncated => Ok(entries),
         FsResult::List {
@@ -344,7 +344,7 @@ fn stat_guest(vm: &str, path: &str) -> Result<mvm_agentd::vsock::FsStat> {
         path: path.to_string(),
         follow_symlinks: false,
     };
-    crate::commands::shared::emit_vsock_rpc_audit(vm, &request);
+    mvm_client::guest::emit_vsock_rpc_audit(vm, &request);
     match crate::commands::vm::fs::fs_request(vm, request)? {
         FsResult::Stat(stat) => Ok(stat),
         FsResult::Error { kind, message } => {
diff --git a/crates/mvm-cli/src/commands/image/materialize.rs b/crates/mvm-cli/src/commands/image/materialize.rs
index e96add218e..a573abaa16 100644
--- a/crates/mvm-cli/src/commands/image/materialize.rs
+++ b/crates/mvm-cli/src/commands/image/materialize.rs
@@ -275,7 +275,7 @@ pub(super) fn rematerialize_cached_image(
     if !reusable_rootfs(&rootfs_abs, prod)? {
         let signer;
         let evidence = if prod {
-            signer = crate::commands::vm::host_signer::load_or_init()
+            signer = mvm_client::host_keypair::load_or_init()
                 .context("load host signing key for the provenance mark")?;
             Some(
                 mvm_build::provenance_mark::SealEvidence::builder(&signer.signing)
diff --git a/crates/mvm-cli/src/commands/image/pull_core.rs b/crates/mvm-cli/src/commands/image/pull_core.rs
index 798101cae5..de91023e2a 100644
--- a/crates/mvm-cli/src/commands/image/pull_core.rs
+++ b/crates/mvm-cli/src/commands/image/pull_core.rs
@@ -306,7 +306,7 @@ fn resolve_run_image_with(
                 sweep_before_builder_vm();
                 let signer;
                 let evidence = if prod {
-                    signer = crate::commands::vm::host_signer::load_or_init()
+                    signer = mvm_client::host_keypair::load_or_init()
                         .context("load host signing key for the provenance mark")?;
                     Some(
                         mvm_build::provenance_mark::SealEvidence::builder(&signer.signing)
@@ -833,7 +833,7 @@ fn materialize_pulled_rootfs(
 ) -> Result<()> {
     let signer = pulled
         .prod
-        .then(crate::commands::vm::host_signer::load_or_init)
+        .then(mvm_client::host_keypair::load_or_init)
         .transpose()
         .context("load host signing key for the provenance mark")?;
     let evidence = signer.as_ref().map(|signer| {
diff --git a/crates/mvm-cli/src/commands/image/trust_policy.rs b/crates/mvm-cli/src/commands/image/trust_policy.rs
index 463d542917..b6e869921b 100644
--- a/crates/mvm-cli/src/commands/image/trust_policy.rs
+++ b/crates/mvm-cli/src/commands/image/trust_policy.rs
@@ -98,7 +98,7 @@ pub(super) fn write_verification_receipt(
     };
     let payload_bytes =
         serde_json::to_vec(&payload).context("serialize OCI verification receipt payload")?;
-    let signer = crate::commands::vm::host_signer::load_or_init()
+    let signer = mvm_client::host_keypair::load_or_init()
         .context("load host signing key for OCI verification receipt")?;
     let receipt = OciVerificationReceipt {
         schema_version: payload.schema_version,
@@ -146,15 +146,15 @@ pub(super) fn trust_decision_from_verification_receipt(
     })?;
     let receipt: OciVerificationReceipt =
         serde_json::from_slice(&bytes).context("parse OCI verification receipt")?;
-    let public_key_path = crate::commands::vm::host_signer::default_keys_dir()?
-        .join(crate::commands::vm::host_signer::PUBLIC_FILENAME);
+    let public_key_path = mvm_client::host_keypair::default_keys_dir()?
+        .join(mvm_client::host_keypair::PUBLIC_FILENAME);
     let public_key_bytes = fs::read(&public_key_path).with_context(|| {
         format!(
             "read host public key for OCI verification receipt {}",
             public_key_path.display()
         )
     })?;
-    let public_key: [u8; crate::commands::vm::host_signer::KEY_BYTES] = public_key_bytes
+    let public_key: [u8; mvm_client::host_keypair::KEY_BYTES] = public_key_bytes
         .as_slice()
         .try_into()
         .map_err(|_| anyhow::anyhow!("host public key must contain exactly 32 bytes"))?;
diff --git a/crates/mvm-cli/src/commands/machine/mod.rs b/crates/mvm-cli/src/commands/machine/mod.rs
index 4c099b8e78..523bc42c19 100644
--- a/crates/mvm-cli/src/commands/machine/mod.rs
+++ b/crates/mvm-cli/src/commands/machine/mod.rs
@@ -55,9 +55,6 @@ use super::Cli;
 use super::build::build;
 use super::vm::exec::{RunArgs, RunProfile, run_secure_started};
 use super::vm::group::VmCmd;
-#[cfg(test)]
-use super::vm::host_signer::PUBLIC_FILENAME;
-use super::vm::host_signer::{host_signer_id, load_or_init};
 use super::vm::{console, down};
 use crate::ui;
 use checkpoint::{ForkVmFullMachineInput, fork_vm_full_machine};
@@ -68,6 +65,9 @@ use lifecycle::{
 use mailbox::{MachineMailboxAction, recv_mailbox};
 use manifest_source::{absolutize_manifest_volume_spec, load_machine_manifest_source};
 #[cfg(test)]
+use mvm_client::host_keypair::PUBLIC_FILENAME;
+use mvm_client::host_keypair::{host_signer_id, load_or_init};
+#[cfg(test)]
 use receipt::verify_machine_start_receipt;
 use receipt::{
     MachineStartJsonSummary, MachineStartReceiptInput, MachineStartReceiptOutcome,
diff --git a/crates/mvm-cli/src/commands/machine/receipt.rs b/crates/mvm-cli/src/commands/machine/receipt.rs
index a2144d32b2..8a48781211 100644
--- a/crates/mvm-cli/src/commands/machine/receipt.rs
+++ b/crates/mvm-cli/src/commands/machine/receipt.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::commands::shared::{self, VolumeSpec};
 #[cfg(test)]
-use crate::commands::vm::host_signer;
+use mvm_client::host_keypair;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub(super) struct MachineStartReceiptInput {
@@ -426,7 +426,7 @@ pub(super) fn load_machine_start_receipt_pubkey(
 ) -> Result<VerifyingKey> {
     let path = match pubkey_path {
         Some(path) => path.to_path_buf(),
-        None => host_signer::default_keys_dir()?.join(PUBLIC_FILENAME),
+        None => host_keypair::default_keys_dir()?.join(PUBLIC_FILENAME),
     };
     let bytes = std::fs::read(&path)
         .with_context(|| format!("reading machine-start receipt pubkey {}", path.display()))?;
diff --git a/crates/mvm-cli/src/commands/machine/runtime.rs b/crates/mvm-cli/src/commands/machine/runtime.rs
index d37feb43df..be5006be50 100644
--- a/crates/mvm-cli/src/commands/machine/runtime.rs
+++ b/crates/mvm-cli/src/commands/machine/runtime.rs
@@ -241,7 +241,7 @@ fn run_persistent_post_start(
     if !args.run.argv.is_empty() && !command_is_followed(args) {
         start_detached_argv(name, &args.run.argv)?;
     } else if !args.run.argv.is_empty() {
-        let outcome = if shared::wait_for_guest_agent(name, 30) {
+        let outcome = if mvm_client::readiness::wait_for_guest_agent(name, 30) {
             console::run_for_exit(
                 cli,
                 console::Args {
@@ -297,7 +297,7 @@ fn command_is_followed(args: &MachineRunArgs) -> bool {
 /// accepted it, rather than following its output.
 fn start_detached_argv(name: &str, argv: &[String]) -> Result<()> {
     anyhow::ensure!(
-        shared::wait_for_guest_agent(name, 30),
+        mvm_client::readiness::wait_for_guest_agent(name, 30),
         "guest agent for {name:?} not reachable to start the command"
     );
     mvm_client::guest::start_process(
diff --git a/crates/mvm-cli/src/commands/ops/audit.rs b/crates/mvm-cli/src/commands/ops/audit.rs
index 721685f5d8..a8919ed57d 100644
--- a/crates/mvm-cli/src/commands/ops/audit.rs
+++ b/crates/mvm-cli/src/commands/ops/audit.rs
@@ -21,10 +21,10 @@ use mvm_client::audit::{AuditSourceId, AuditSourceKind, LocalAuditReader};
 use mvm_contract::merkle::{InclusionProof, SignedAuditRoot, verify_membership};
 use mvm_core::user_config::MvmConfig;
 
-use super::super::vm::audit_chain::{AuditEmitter, audit_path_for_tenant, default_audit_dir};
-use super::super::vm::host_signer;
 use super::Cli;
 use mvm_client::audit::chain::decisions::DecisionStore;
+use mvm_client::audit::chain::emitter::{AuditEmitter, audit_path_for_tenant, default_audit_dir};
+use mvm_client::host_keypair;
 use mvm_contract::provenance::DecisionId;
 
 use inspect::audit_tail;
@@ -607,7 +607,7 @@ impl ExportArgs {
 }
 
 fn audit_receipts_export(args: &ExportArgs) -> Result<()> {
-    let signer = host_signer::load_or_init().context("loading host signer to export receipts")?;
+    let signer = host_keypair::load_or_init().context("loading host signer to export receipts")?;
     let dir = default_audit_dir().context("resolving audit directory")?;
 
     if let Some(path) = &args.archive {
@@ -927,7 +927,7 @@ fn verify_cert(
 /// Build, sign, and publish a Merkle root over the tenant's audit chain.
 fn audit_publish_root(tenant: &str) -> Result<()> {
     let signer =
-        host_signer::load_or_init().context("loading host signer to publish audit root")?;
+        host_keypair::load_or_init().context("loading host signer to publish audit root")?;
     let emitter = AuditEmitter::new(signer.signing).context("opening host audit emitter")?;
     let signed = emitter
         .publish_root(tenant)
@@ -948,7 +948,7 @@ fn audit_prove(tenant: &str, selector: &str, json: bool) -> Result<()> {
     use mvm_contract::merkle::build_inclusion_proof;
 
     let signer =
-        host_signer::load_or_init().context("loading host signer to build inclusion proof")?;
+        host_keypair::load_or_init().context("loading host signer to build inclusion proof")?;
     let dir = default_audit_dir()?;
     // Read the verified leaf set once; the selector resolves against exactly
     // the leaves the proof is built over, so indices can't drift.
@@ -1083,7 +1083,7 @@ fn audit_verify_inclusion(
     let vk = match pubkey_path {
         Some(p) => load_verifying_key(p)?,
         None => {
-            host_signer::load_or_init()
+            host_keypair::load_or_init()
                 .context("loading host signer public key")?
                 .verifying
         }
@@ -1371,7 +1371,7 @@ fn audit_verify(tenant: &str) -> Result<()> {
 
     // Both chain kinds are signed under the host key; load it once.
     let signer =
-        host_signer::load_or_init().context("loading host signer to verify audit chain")?;
+        host_keypair::load_or_init().context("loading host signer to verify audit chain")?;
 
     // The canonical verification seam: the same source discovery +
     // verification the verified-audit UI reader uses, so the CLI and UI
@@ -2340,7 +2340,7 @@ mod chain_summary_tests {
         let mut env = mvm_core::util::test_env::TestEnv::new();
         let tmp = tempfile::tempdir().unwrap();
         env.set("MVM_HOME", tmp.path());
-        let signer = host_signer::load_or_init().unwrap();
+        let signer = host_keypair::load_or_init().unwrap();
         let dir = default_audit_dir().unwrap();
         let emitter = mvm_hostd::audit::emitter::AuditEmitter::new(signer.signing.clone()).unwrap();
         let plan = PlanFixture::new().tenant("local").plan_id("plan-a").build();
diff --git a/crates/mvm-cli/src/commands/ops/audit/sessions.rs b/crates/mvm-cli/src/commands/ops/audit/sessions.rs
index 012a6b4308..7d449103e0 100644
--- a/crates/mvm-cli/src/commands/ops/audit/sessions.rs
+++ b/crates/mvm-cli/src/commands/ops/audit/sessions.rs
@@ -11,7 +11,8 @@ use mvm_client::audit::chain::session::{
     list_sessions, resolve_session, session_events, verify_session_in_lines, workload_events,
 };
 
-use super::{default_audit_dir, host_signer, print_chain_line, ui};
+use super::{default_audit_dir, print_chain_line, ui};
+use mvm_client::host_keypair;
 
 /// `trust audit verify [SESSION]`.
 #[derive(clap::Args, Debug, Clone)]
@@ -131,7 +132,7 @@ pub(super) fn verified_lines(tenant: &str) -> Result<Option<Vec<String>>> {
         return Ok(None);
     }
     let signer =
-        host_signer::load_or_init().context("loading host signer to read the audit chain")?;
+        host_keypair::load_or_init().context("loading host signer to read the audit chain")?;
     mvm_client::audit::chain::merkle::read_leaves(&dir, tenant, &signer.verifying)
         .map(Some)
         .with_context(|| {
@@ -327,7 +328,7 @@ pub(in crate::commands) fn audit_verify_session(
     let dir = default_audit_dir()?;
     let report = if has_chain(&dir, tenant)? {
         let signer =
-            host_signer::load_or_init().context("loading host signer to verify the session")?;
+            host_keypair::load_or_init().context("loading host signer to verify the session")?;
         // One walk from genesis serves both the selector and the verdict.
         match mvm_client::audit::chain::session::read_lines_from_genesis(
             &dir,
diff --git a/crates/mvm-cli/src/commands/ops/audit_posture.rs b/crates/mvm-cli/src/commands/ops/audit_posture.rs
index 5f7e55b05c..12ce15d144 100644
--- a/crates/mvm-cli/src/commands/ops/audit_posture.rs
+++ b/crates/mvm-cli/src/commands/ops/audit_posture.rs
@@ -192,7 +192,7 @@ fn check_audit_chain(home: Option<&std::path::Path>) -> PostureCheck {
     // Verifying the chain requires the host signer's verifying
     // key. Load it lazily — if it fails, surface that.
     let keys_dir = mvm_core::config::mvm_keys_dir();
-    match crate::commands::vm::host_signer::load_or_init_at(&keys_dir) {
+    match mvm_client::host_keypair::load_or_init_at(&keys_dir) {
         Ok(signer) => {
             match mvm_client::audit::chain::supervisor::verify_audit_chain(&path, &signer.verifying)
             {
diff --git a/crates/mvm-cli/src/commands/ops/transcript.rs b/crates/mvm-cli/src/commands/ops/transcript.rs
index d9936481dc..144d174db9 100644
--- a/crates/mvm-cli/src/commands/ops/transcript.rs
+++ b/crates/mvm-cli/src/commands/ops/transcript.rs
@@ -31,7 +31,7 @@ use mvm_core::transcript::{
     TranscriptWriterConfig,
 };
 
-use super::super::vm::host_signer::PUBLIC_FILENAME;
+use mvm_client::host_keypair::PUBLIC_FILENAME;
 
 const DEFAULT_TENANT: &str = "local";
 const DEFAULT_MAX_BYTES: u64 = 64 * 1024 * 1024;
@@ -310,7 +310,7 @@ impl TranscriptCtx {
             transcript::recover_abandoned_at(&mut manifest, transcript::retention_now()?)?;
             write_manifest(&dir, &manifest)?;
         }
-        let signer = super::super::vm::host_signer::load_or_init_at(&self.keys_dir)
+        let signer = mvm_client::host_keypair::load_or_init_at(&self.keys_dir)
             .context("loading the host signer to anchor the sealed transcript")?;
         match self.matching_chain_anchors(tenant, capture_id, &manifest)? {
             0 => AuditEmitter::with_dir(signer.signing, &self.audit_dir)
diff --git a/crates/mvm-cli/src/commands/pool.rs b/crates/mvm-cli/src/commands/pool.rs
index b4b5b01e37..83d7540057 100644
--- a/crates/mvm-cli/src/commands/pool.rs
+++ b/crates/mvm-cli/src/commands/pool.rs
@@ -36,10 +36,10 @@ use sha2::{Digest, Sha256};
 
 use super::Cli;
 use super::vm::checkpoint::{ClaimChainAnchor, SignedChainAnchor};
-use super::vm::host_signer;
 use mvm_client::admission::{
     AdmittedPlan, InMemoryNonceLedger, SystemClock, admit_for_run, stash_plan_and_mint_verb_grant,
 };
+use mvm_client::host_keypair;
 use mvm_contract::builder::BuilderError;
 use mvm_core::plan::{PlanSeccompTier, SecretReleasePolicy, SynthesisInput};
 
@@ -493,9 +493,9 @@ fn audit_captured_parent(
         handle.vcpus,
         handle.mem_mib,
     )?;
-    let signer = host_signer::load_or_init()
+    let signer = host_keypair::load_or_init()
         .context("loading the host signer to sign the parent's creation entry")?;
-    let emitter = super::vm::audit_chain::AuditEmitter::new(signer.signing)
+    let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .context("opening the audit chain to record the parent's creation")?
         .with_receipts()
         .with_decisions()
@@ -3049,12 +3049,12 @@ fn run_warm(pool: &SupervisorStandbyPool, req: &WarmRequest) -> Result<()> {
         launch.backend.late_volume_slots(),
         || {
             // Ensure the host signer exists only for a parent a launch can claim.
-            let signer = host_signer::load_or_init()?;
+            let signer = host_keypair::load_or_init()?;
             warm_to_target(
                 pool,
                 &WarmParams {
                     backend: &launch.backend,
-                    signer_id: &host_signer::host_signer_id(),
+                    signer_id: &host_keypair::host_signer_id(),
                     signing_key_path: &signer.secret_path,
                     target,
                     launch: &launch.start_config,
diff --git a/crates/mvm-cli/src/commands/pool/refill.rs b/crates/mvm-cli/src/commands/pool/refill.rs
index ea778f55fc..21f2486b85 100644
--- a/crates/mvm-cli/src/commands/pool/refill.rs
+++ b/crates/mvm-cli/src/commands/pool/refill.rs
@@ -20,7 +20,7 @@ use super::{
     SupervisorStandbyPool, WarmParams, WarmRequest, compat_for_launch, resolve_warm_launch,
     warm_to_target,
 };
-use crate::commands::vm::host_signer;
+use mvm_client::host_keypair;
 
 /// The launch shape a refill prepares a standby for: the arguments a
 /// `pool warm` of the same image and sizing would take.
@@ -186,13 +186,13 @@ fn refill_one(
         return Ok(());
     }
     refill_phase(started, "room_made");
-    let signer = host_signer::load_or_init()?;
+    let signer = host_keypair::load_or_init()?;
     refill_phase(started, "signer_loaded");
     let result = warm_to_target(
         pool,
         &WarmParams {
             backend: &launch.backend,
-            signer_id: &host_signer::host_signer_id(),
+            signer_id: &host_keypair::host_signer_id(),
             signing_key_path: &signer.secret_path,
             target,
             launch: &launch.start_config,
diff --git a/crates/mvm-cli/src/commands/shared/mod.rs b/crates/mvm-cli/src/commands/shared/mod.rs
index 3767525016..a5d410fc2e 100644
--- a/crates/mvm-cli/src/commands/shared/mod.rs
+++ b/crates/mvm-cli/src/commands/shared/mod.rs
@@ -14,7 +14,6 @@ mod signed_input;
 mod snapshot_key;
 mod state;
 mod vcpu_default;
-mod vsock;
 
 pub(super) use build_mode::BuildModeFlags;
 pub(super) use event::PhaseEvent;
@@ -44,4 +43,3 @@ pub(in crate::commands) use signed_input::read_signed_input;
 pub(in crate::commands) use snapshot_key::ensure_snapshot_key;
 pub(super) use state::{CHILD_PIDS, IN_CONSOLE_MODE};
 pub(crate) use vcpu_default::default_vcpus;
-pub(super) use vsock::{emit_vsock_rpc_audit, wait_for_guest_agent};
diff --git a/crates/mvm-cli/src/commands/shared/vsock.rs b/crates/mvm-cli/src/commands/shared/vsock.rs
deleted file mode 100644
index 99bd3f3fd2..0000000000
--- a/crates/mvm-cli/src/commands/shared/vsock.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Vsock helpers for talking to the in-guest agent.
-//!
-//! Routes through the canonical `mvm_runtime::vsock_transport::for_vm`
-//! dispatcher — the same selector `invoke`/`exec`/`readiness` use. It
-//! probes the live backend (hvf agent bridge → libkrun → hvf per-port vsock →
-//! firecracker) per VM, so a VM started under any backend reaches its agent
-//! on the right transport.
-
-pub(crate) use mvm_client::readiness::wait_for_guest_agent;
-
-pub(crate) use mvm_client::guest::emit_vsock_rpc_audit;
diff --git a/crates/mvm-cli/src/commands/trust/add.rs b/crates/mvm-cli/src/commands/trust/add.rs
index 2e237e0e7d..d567b34717 100644
--- a/crates/mvm-cli/src/commands/trust/add.rs
+++ b/crates/mvm-cli/src/commands/trust/add.rs
@@ -25,7 +25,7 @@ use super::super::Cli;
 pub(in crate::commands) struct Args {
     /// Path to a 32-byte Ed25519 public-key file. No PEM, no
     /// headers — raw bytes only. Bundles publish this format via
-    /// `~/.mvm/keys/host-signer.pub` after `host_signer::load_or_init`.
+    /// `~/.mvm/keys/host-signer.pub` after `host_keypair::load_or_init`.
     #[arg(value_name = "PUBKEY")]
     pub pubkey: PathBuf,
     /// Overwrite an existing entry with the same `key_id`.
diff --git a/crates/mvm-cli/src/commands/vm/audit_chain.rs b/crates/mvm-cli/src/commands/vm/audit_chain.rs
deleted file mode 100644
index efeae0e6de..0000000000
--- a/crates/mvm-cli/src/commands/vm/audit_chain.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Re-export shim: the chain-signed `AuditEmitter` now lives in
-//! `mvm_client::audit::chain::emitter`.
-pub(crate) use mvm_client::audit::chain::emitter::*;
diff --git a/crates/mvm-cli/src/commands/vm/checkpoint.rs b/crates/mvm-cli/src/commands/vm/checkpoint.rs
index 19014c9e89..c6bb3aa662 100644
--- a/crates/mvm-cli/src/commands/vm/checkpoint.rs
+++ b/crates/mvm-cli/src/commands/vm/checkpoint.rs
@@ -496,7 +496,7 @@ fn seal_machine_input_cursor(
 }
 
 pub(crate) fn bind_checkpoint_created(name: &str, meta: &mvm_core::checkpoint::CheckpointMeta) {
-    let plan = match super::plan_persist::read_plan(name) {
+    let plan = match mvm_client::audit::chain::plan_persist::read_plan(name) {
         Ok(p) => p,
         Err(e) => {
             tracing::warn!(error = %e, vm = name,
@@ -504,14 +504,14 @@ pub(crate) fn bind_checkpoint_created(name: &str, meta: &mvm_core::checkpoint::C
             return;
         }
     };
-    let signer = match super::host_signer::load_or_init() {
+    let signer = match mvm_client::host_keypair::load_or_init() {
         Ok(s) => s,
         Err(e) => {
             tracing::warn!(error = %e, "host signer unavailable; chain entry skipped");
             return;
         }
     };
-    let emitter = match super::audit_chain::AuditEmitter::new(signer.signing)
+    let emitter = match mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .map(|e| e.with_receipts().with_decisions())
     {
         Ok(Ok(e)) => e,
@@ -1165,7 +1165,7 @@ fn parent_agent_verb_override(
     let Ok(parent_meta) = store.read_meta(parent_checkpoint) else {
         return Vec::new();
     };
-    let Ok(plan) = super::plan_persist::read_plan(&parent_meta.vm_name) else {
+    let Ok(plan) = mvm_client::audit::chain::plan_persist::read_plan(&parent_meta.vm_name) else {
         return Vec::new();
     };
     plan.agent_verbs
@@ -1195,7 +1195,7 @@ fn parent_network_mode(
     let Ok(parent_meta) = store.read_meta(parent_checkpoint) else {
         return fallback;
     };
-    let Ok(plan) = super::plan_persist::read_plan(&parent_meta.vm_name) else {
+    let Ok(plan) = mvm_client::audit::chain::plan_persist::read_plan(&parent_meta.vm_name) else {
         return fallback;
     };
     plan.network_mode
@@ -1217,7 +1217,7 @@ fn parent_secret_names(parent_checkpoint: &CheckpointId, store: &CheckpointStore
     let Ok(parent_meta) = store.read_meta(parent_checkpoint) else {
         return Vec::new();
     };
-    let Ok(plan) = super::plan_persist::read_plan(&parent_meta.vm_name) else {
+    let Ok(plan) = mvm_client::audit::chain::plan_persist::read_plan(&parent_meta.vm_name) else {
         return Vec::new();
     };
     plan.secrets.into_iter().map(|b| b.name).collect()
@@ -1323,7 +1323,7 @@ fn parent_plan_resources(
         Ok(m) => m,
         Err(_) => return (None, None),
     };
-    let plan = match super::plan_persist::read_plan(&parent_meta.vm_name) {
+    let plan = match mvm_client::audit::chain::plan_persist::read_plan(&parent_meta.vm_name) {
         Ok(p) => p,
         Err(_) => return (None, None),
     };
@@ -1345,9 +1345,9 @@ pub(crate) fn bind_checkpoint_forked(
     // lineage entry binds to the admitted identity the fork branched from.
     let parent_vm_name = store.read_meta(parent).ok().map(|m| m.vm_name);
     let plan =
-        match super::plan_persist::read_plan(&child.vm_name).or_else(|_| {
+        match mvm_client::audit::chain::plan_persist::read_plan(&child.vm_name).or_else(|_| {
             match parent_vm_name.as_deref() {
-                Some(name) => super::plan_persist::read_plan(name),
+                Some(name) => mvm_client::audit::chain::plan_persist::read_plan(name),
                 None => Err(anyhow::anyhow!("parent checkpoint has no recorded vm_name")),
             }
         }) {
@@ -1358,14 +1358,14 @@ pub(crate) fn bind_checkpoint_forked(
                 return Ok(());
             }
         };
-    let signer = match super::host_signer::load_or_init() {
+    let signer = match mvm_client::host_keypair::load_or_init() {
         Ok(s) => s,
         Err(e) => {
             tracing::warn!(error = %e, "host signer unavailable; chain entry skipped");
             return Ok(());
         }
     };
-    let emitter = super::audit_chain::AuditEmitter::new(signer.signing)
+    let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .map(|e| e.with_receipts())
         .context("refusing an unaudited fork: audit emitter unavailable")?;
     let binding_store = mvm_client::checkpoint::FileBindingStore::default_location()
@@ -2898,8 +2898,8 @@ mod tests {
             .build();
         store.write_meta(&meta).unwrap();
 
-        let signer = super::super::host_signer::load_or_init().unwrap();
-        let emitter = super::super::audit_chain::AuditEmitter::new(signer.signing).unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
+        let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing).unwrap();
         let plan = mvm_core::plan::test_support::PlanFixture::new()
             .tenant("local")
             .plan_id("plan-verify")
@@ -2963,8 +2963,8 @@ mod tests {
         .build();
         let store = CheckpointStore::open();
         store.write_meta(&meta).unwrap();
-        let signer = super::super::host_signer::load_or_init().unwrap();
-        let emitter = super::super::audit_chain::AuditEmitter::new(signer.signing).unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
+        let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing).unwrap();
         let plan = mvm_core::plan::test_support::PlanFixture::new()
             .tenant("local")
             .plan_id("plan-snapshot-lineage")
@@ -3084,8 +3084,8 @@ mod tests {
     /// will. Returns nothing; the store + chain are the observable state.
     fn seed_audited_image_node(store: &ImageStore, node: &ImageNode) {
         store.save(node).unwrap();
-        let signer = super::super::host_signer::load_or_init().unwrap();
-        let emitter = super::super::audit_chain::AuditEmitter::new(signer.signing).unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
+        let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing).unwrap();
         let plan = mvm_core::plan::test_support::PlanFixture::new()
             .tenant("local")
             .plan_id("plan-image-verify")
@@ -3156,8 +3156,8 @@ mod tests {
         env.isolate_mvm_home(tmp.path());
 
         let store = ImageStore::open();
-        let signer = super::super::host_signer::load_or_init().unwrap();
-        let emitter = super::super::audit_chain::AuditEmitter::new(signer.signing).unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
+        let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing).unwrap();
         let plan = mvm_core::plan::test_support::PlanFixture::new()
             .tenant("local")
             .plan_id("plan-build-path")
@@ -3258,8 +3258,8 @@ mod tests {
         env.isolate_mvm_home(tmp.path());
 
         let store = ImageStore::open();
-        let signer = super::super::host_signer::load_or_init().unwrap();
-        let emitter = super::super::audit_chain::AuditEmitter::new(signer.signing).unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
+        let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing).unwrap();
         let plan = mvm_core::plan::test_support::PlanFixture::new()
             .tenant("local")
             .plan_id("plan-oci-pull")
diff --git a/crates/mvm-cli/src/commands/vm/checkpoint/fork_vm_full.rs b/crates/mvm-cli/src/commands/vm/checkpoint/fork_vm_full.rs
index 17ed287979..1873cf1027 100644
--- a/crates/mvm-cli/src/commands/vm/checkpoint/fork_vm_full.rs
+++ b/crates/mvm-cli/src/commands/vm/checkpoint/fork_vm_full.rs
@@ -483,7 +483,7 @@ fn fork_restrict_agent_verbs(p: &AdmitForkedChildParams<'_>) -> Result<bool> {
             let recorded_plan_id = anchor
                 .checkpoint_plan_id(p.parent_meta)?
                 .context("replay source checkpoint has no signed plan identity")?;
-            let source = super::super::plan_persist::read_plan(&p.parent_meta.vm_name)
+            let source = mvm_client::audit::chain::plan_persist::read_plan(&p.parent_meta.vm_name)
                 .context("reading replay source plan")?;
             mvm_core::plan::verify_plan_id(&source)
                 .context("verifying replay source plan content id")?;
@@ -1081,8 +1081,8 @@ mod tests {
             .unwrap();
         let meta = mvm_runtime::checkpoint::capture_vm_full(store, params, &CapturedParent(rootfs))
             .unwrap();
-        let signer = crate::commands::vm::host_signer::load_or_init().unwrap();
-        let emitter = crate::commands::vm::audit_chain::AuditEmitter::new(signer.signing).unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
+        let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing).unwrap();
         let plan = mvm_core::plan::test_support::PlanFixture::new()
             .tenant("local")
             .plan_id("plan-fork-parent")
@@ -1454,7 +1454,8 @@ mod tests {
             .expect("a parent with no plan forks unpinned");
         let mut parent_plan = unpinned.admission.admitted.plan().clone();
         assert!(parent_plan.bundle.is_none());
-        crate::commands::vm::plan_persist::write_plan(&parent_meta.vm_name, &parent_plan).unwrap();
+        mvm_client::audit::chain::plan_persist::write_plan(&parent_meta.vm_name, &parent_plan)
+            .unwrap();
         fork_child_of(&store, id, &parent_meta, "plain-child-2")
             .expect("a parent whose plan names no bundle forks as before");
 
@@ -1464,7 +1465,8 @@ mod tests {
             &[0; 64],
             mvm_core::plan::bundle::KeyId("publisher".into()),
         ));
-        crate::commands::vm::plan_persist::write_plan(&parent_meta.vm_name, &parent_plan).unwrap();
+        mvm_client::audit::chain::plan_persist::write_plan(&parent_meta.vm_name, &parent_plan)
+            .unwrap();
 
         let err = match fork_child_of(&store, id, &parent_meta, "bundle-child") {
             Ok(_) => panic!("a child of an uninstalled bundle must not be admitted"),
diff --git a/crates/mvm-cli/src/commands/vm/checkpoint/revert.rs b/crates/mvm-cli/src/commands/vm/checkpoint/revert.rs
index 508dd118b8..0fbc77df3f 100644
--- a/crates/mvm-cli/src/commands/vm/checkpoint/revert.rs
+++ b/crates/mvm-cli/src/commands/vm/checkpoint/revert.rs
@@ -455,14 +455,14 @@ const IMAGE_REVERT_INTENT: &str = "image:revert";
 /// as capture does); a present signer whose emit fails is fatal, so an
 /// un-auditable restore refuses before it re-runs.
 fn emit_image_revert_audit(node: &ImageNode, via: RevertVia, reference: &str) -> Result<()> {
-    let signer = match crate::commands::vm::host_signer::load_or_init() {
+    let signer = match mvm_client::host_keypair::load_or_init() {
         Ok(s) => s,
         Err(e) => {
             tracing::warn!(error = %e, "host signer unavailable; image.reverted chain entry skipped");
             return Ok(());
         }
     };
-    let emitter = crate::commands::vm::audit_chain::AuditEmitter::new(signer.signing)
+    let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .map(|e| e.with_receipts())
         .context("refusing an unaudited image restore: audit emitter unavailable")?;
     // The node's content-address is always a valid 64-hex digest — bind the
@@ -635,7 +635,7 @@ fn emit_revert_audit(
     target: &CheckpointMeta,
     via: RevertVia,
 ) -> Result<()> {
-    let plan = match crate::commands::vm::plan_persist::read_plan(restored_vm_name) {
+    let plan = match mvm_client::audit::chain::plan_persist::read_plan(restored_vm_name) {
         Ok(p) => p,
         Err(e) => {
             tracing::warn!(error = %e, vm = restored_vm_name,
@@ -643,14 +643,14 @@ fn emit_revert_audit(
             return Ok(());
         }
     };
-    let signer = match crate::commands::vm::host_signer::load_or_init() {
+    let signer = match mvm_client::host_keypair::load_or_init() {
         Ok(s) => s,
         Err(e) => {
             tracing::warn!(error = %e, "host signer unavailable; restore chain entry skipped");
             return Ok(());
         }
     };
-    let emitter = crate::commands::vm::audit_chain::AuditEmitter::new(signer.signing)
+    let emitter = mvm_client::audit::chain::emitter::AuditEmitter::new(signer.signing)
         .map(|e| e.with_receipts())
         .context("refusing an unaudited restore: audit emitter unavailable")?;
     bind_checkpoint_restored(&emitter, &plan, target, restored_vm_name, via.as_str())
@@ -673,7 +673,7 @@ mod tests {
     // ── seed helpers: a store record + its host-signed creation entry ─────────
 
     fn emitter() -> (AuditEmitter, mvm_core::plan::ExecutionPlan) {
-        let signer = crate::commands::vm::host_signer::load_or_init().unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
         let em = AuditEmitter::new(signer.signing).unwrap();
         let plan = PlanFixture::new()
             .tenant("local")
@@ -993,7 +993,7 @@ mod tests {
 
         // The revert is distinctly audited BEFORE handoff: image.created (seed) +
         // image.reverted (revert), both chain-signed and verifiable.
-        let signer = crate::commands::vm::host_signer::load_or_init().unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
         let path = mvm_hostd::audit::emitter::default_audit_dir()
             .unwrap()
             .join("local.jsonl");
@@ -1161,7 +1161,7 @@ mod tests {
             .tenant("local")
             .plan_id("plan-restored")
             .build();
-        crate::commands::vm::plan_persist::write_plan(restored_vm, &plan).unwrap();
+        mvm_client::audit::chain::plan_persist::write_plan(restored_vm, &plan).unwrap();
 
         let target = CheckpointMeta::builder(
             CheckpointId::new("target"),
@@ -1178,7 +1178,7 @@ mod tests {
 
         emit_revert_audit(restored_vm, &target, RevertVia::Rewind).unwrap();
 
-        let signer = crate::commands::vm::host_signer::load_or_init().unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
         let path = mvm_hostd::audit::emitter::default_audit_dir()
             .unwrap()
             .join("local.jsonl");
diff --git a/crates/mvm-cli/src/commands/vm/checkpoint/timeline.rs b/crates/mvm-cli/src/commands/vm/checkpoint/timeline.rs
index 8933a747ff..28401499a5 100644
--- a/crates/mvm-cli/src/commands/vm/checkpoint/timeline.rs
+++ b/crates/mvm-cli/src/commands/vm/checkpoint/timeline.rs
@@ -428,7 +428,7 @@ mod tests {
     // ── seed helpers: a store record + its host-signed creation entry ─────────
 
     fn emitter() -> (AuditEmitter, mvm_core::plan::ExecutionPlan) {
-        let signer = crate::commands::vm::host_signer::load_or_init().unwrap();
+        let signer = mvm_client::host_keypair::load_or_init().unwrap();
         let em = AuditEmitter::new(signer.signing).unwrap();
         let plan = PlanFixture::new()
             .tenant("local")
diff --git a/crates/mvm-cli/src/commands/vm/console.rs b/crates/mvm-cli/src/commands/vm/console.rs
index dd0e315fcf..56c756563f 100644
--- a/crates/mvm-cli/src/commands/vm/console.rs
+++ b/crates/mvm-cli/src/commands/vm/console.rs
@@ -257,7 +257,7 @@ pub(in crate::commands) fn run_for_exit(_cli: &Cli, args: Args, _cfg: &MvmConfig
         let transport = pick_console_transport(name)?;
         let mut stream = transport.connect(mvm_agentd::vsock::GUEST_AGENT_PORT)?;
         // Inbound vsock RPC audit (verb=exec).
-        super::shared::emit_vsock_rpc_audit(
+        mvm_client::guest::emit_vsock_rpc_audit(
             name,
             &mvm_agentd::vsock::GuestRequest::Exec {
                 command: cmd.to_string(),
@@ -512,7 +512,7 @@ fn console_call(
     req: &mvm_agentd::vsock::GuestRequest,
 ) -> Result<mvm_agentd::vsock::GuestResponse> {
     let mut stream = console_control(transport)?;
-    super::shared::emit_vsock_rpc_audit(name, req);
+    mvm_client::guest::emit_vsock_rpc_audit(name, req);
     match mvm_agentd::vsock::call_unary(&mut stream, req)? {
         mvm_agentd::vsock::GuestResponse::Error { message } => anyhow::bail!("{message}"),
         other => Ok(other),
diff --git a/crates/mvm-cli/src/commands/vm/cp.rs b/crates/mvm-cli/src/commands/vm/cp.rs
index 4db30ed381..64439388de 100644
--- a/crates/mvm-cli/src/commands/vm/cp.rs
+++ b/crates/mvm-cli/src/commands/vm/cp.rs
@@ -253,7 +253,7 @@ fn guest_exists(vm: &str, path: &str) -> Result<bool> {
         follow_symlinks: false,
     };
     // Inbound vsock RPC audit.
-    super::shared::emit_vsock_rpc_audit(vm, &req);
+    mvm_client::guest::emit_vsock_rpc_audit(vm, &req);
     match super::fs::fs_request(vm, req)? {
         FsResult::Stat(_) => Ok(true),
         FsResult::Error {
@@ -271,7 +271,7 @@ fn guest_stat(vm: &str, path: &str) -> Result<mvm_agentd::vsock::FsStat> {
         follow_symlinks: true,
     };
     // Inbound vsock RPC audit.
-    super::shared::emit_vsock_rpc_audit(vm, &req);
+    mvm_client::guest::emit_vsock_rpc_audit(vm, &req);
     match unwrap_fs(super::fs::fs_request(vm, req)?)? {
         FsResult::Stat(stat) => Ok(stat),
         other => bail!("Unexpected FsResult variant for Stat: {:?}", other),
diff --git a/crates/mvm-cli/src/commands/vm/exec.rs b/crates/mvm-cli/src/commands/vm/exec.rs
index 1c21d7126a..809caee325 100644
--- a/crates/mvm-cli/src/commands/vm/exec.rs
+++ b/crates/mvm-cli/src/commands/vm/exec.rs
@@ -20,7 +20,7 @@ use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 
 use super::Cli;
-use super::host_signer::{host_signer_id, load_or_init};
+use mvm_client::host_keypair::{host_signer_id, load_or_init};
 
 pub(in crate::commands) mod application_source;
 mod composition;
@@ -855,7 +855,7 @@ pub(in crate::commands) fn run_secure_started(
         // Persist the bare plan so the pre-start moat / endpoint can read it
         // on the backends that consume it from disk (mirrors the invoke path).
         if super::up::persists_plan_before_start(&admit_backend) {
-            super::plan_persist::write_plan(vm_name, c.admitted.plan())
+            mvm_client::audit::chain::plan_persist::write_plan(vm_name, c.admitted.plan())
                 .context("persisting admitted plan for the transient run")?;
         }
         let guest_profile = super::up::guest_profile_for_boot(admit_is_dev, rootfs);
diff --git a/crates/mvm-cli/src/commands/vm/exec/receipt_verify.rs b/crates/mvm-cli/src/commands/vm/exec/receipt_verify.rs
index b178865bbc..fa7ff3d370 100644
--- a/crates/mvm-cli/src/commands/vm/exec/receipt_verify.rs
+++ b/crates/mvm-cli/src/commands/vm/exec/receipt_verify.rs
@@ -6,8 +6,8 @@ use anyhow::{Context, Result};
 use base64::Engine as _;
 use ed25519_dalek::{Signature, Verifier, VerifyingKey};
 
-use super::super::host_signer::PUBLIC_FILENAME;
 use super::{SignedRunReceipt, sha256_hex};
+use mvm_client::host_keypair::PUBLIC_FILENAME;
 
 pub(super) fn verify_run_receipt(
     path: &Path,
@@ -56,11 +56,11 @@ pub(super) fn verify_run_receipt(
 fn load_receipt_pubkey(path: Option<&Path>) -> Result<VerifyingKey> {
     let path = match path {
         Some(path) => path.to_path_buf(),
-        None => super::super::host_signer::default_keys_dir()?.join(PUBLIC_FILENAME),
+        None => mvm_client::host_keypair::default_keys_dir()?.join(PUBLIC_FILENAME),
     };
     let bytes = std::fs::read(&path)
         .with_context(|| format!("reading trusted receipt public key {}", path.display()))?;
-    let key: [u8; super::super::host_signer::KEY_BYTES] = bytes
+    let key: [u8; mvm_client::host_keypair::KEY_BYTES] = bytes
         .as_slice()
         .try_into()
         .map_err(|_| anyhow::anyhow!("{} must contain exactly 32 bytes", path.display()))?;
diff --git a/crates/mvm-cli/src/commands/vm/host_signer.rs b/crates/mvm-cli/src/commands/vm/host_signer.rs
deleted file mode 100644
index 7743d4f874..0000000000
--- a/crates/mvm-cli/src/commands/vm/host_signer.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Re-export shim: the host signing keypair is `mvm_client::host_keypair`. The
-//! `host_signer` path here is preserved so existing call sites compile unchanged.
-pub(crate) use mvm_client::host_keypair::*;
diff --git a/crates/mvm-cli/src/commands/vm/mod.rs b/crates/mvm-cli/src/commands/vm/mod.rs
index f71584d663..ceea2822ec 100644
--- a/crates/mvm-cli/src/commands/vm/mod.rs
+++ b/crates/mvm-cli/src/commands/vm/mod.rs
@@ -2,7 +2,6 @@
 
 pub(super) use mvm_client::admission::agent_verbs;
 pub(super) mod artifact;
-pub(super) mod audit_chain;
 pub(in crate::commands) mod checkpoint;
 pub(crate) mod console;
 pub(super) mod cp;
@@ -21,7 +20,6 @@ pub(super) mod fs;
 pub(super) mod group;
 pub(in crate::commands) mod host_notices;
 mod host_services;
-pub(super) mod host_signer;
 pub(crate) mod invoke;
 pub(crate) mod launch_sample;
 pub(super) mod logs;
@@ -29,7 +27,6 @@ pub(super) mod managed_secrets;
 mod outputs;
 pub(super) mod pause;
 pub(crate) mod phase_timing;
-pub(super) mod plan_persist;
 pub(in crate::commands) mod prepare;
 pub(super) mod proc;
 pub(super) mod prompt;
diff --git a/crates/mvm-cli/src/commands/vm/plan_persist.rs b/crates/mvm-cli/src/commands/vm/plan_persist.rs
deleted file mode 100644
index c87f23e239..0000000000
--- a/crates/mvm-cli/src/commands/vm/plan_persist.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-//! Re-export shim: plan persistence now lives in `mvm_client::audit::chain::plan_persist`.
-pub(crate) use mvm_client::audit::chain::plan_persist::*;
diff --git a/crates/mvm-cli/src/commands/vm/session.rs b/crates/mvm-cli/src/commands/vm/session.rs
index d1b7df4fce..bc425e18a1 100644
--- a/crates/mvm-cli/src/commands/vm/session.rs
+++ b/crates/mvm-cli/src/commands/vm/session.rs
@@ -566,7 +566,7 @@ fn dispatch_run_code(
     let request_code = code.clone();
     let req = mvm_agentd::vsock::GuestRequest::RunCode { code, timeout_secs };
     // Inbound vsock RPC audit.
-    super::shared::emit_vsock_rpc_audit(&record.vm_name, &req);
+    mvm_client::guest::emit_vsock_rpc_audit(&record.vm_name, &req);
     let terminal = mvm_agentd::vsock::send_run_code_streaming(
         &mut stream,
         &request_code,
diff --git a/crates/mvm-cli/src/commands/vm/wait.rs b/crates/mvm-cli/src/commands/vm/wait.rs
index 9c32cc23fe..54440f3dee 100644
--- a/crates/mvm-cli/src/commands/vm/wait.rs
+++ b/crates/mvm-cli/src/commands/vm/wait.rs
@@ -4,7 +4,7 @@
 //! Both commands share a `fetch_readiness` helper that drives the
 //! protocol-hello prelude with
 //! `GuestCapability::Readiness` and dispatches a single
-//! `ReadinessStatus` request through `mvm_runtime::vsock_transport` (so
+//! `ReadinessStatus` request through `mvm_vmm::vsock_transport` (so
 //! Firecracker, libkrun, Apple Container, and Docker backends all
 //! work without per-backend code in the CLI).
 //!
diff --git a/crates/mvm-cli/src/exec.rs b/crates/mvm-cli/src/exec.rs
index 511210ad88..e77d883114 100644
--- a/crates/mvm-cli/src/exec.rs
+++ b/crates/mvm-cli/src/exec.rs
@@ -15,8 +15,8 @@ use anyhow::{Context, Result};
 use mvm_core::launch_trace::PhaseTimingMode;
 use mvm_core::vm_backend::{SnapshotCapability, VmId, VmStartConfig, VmVolume};
 use mvm_runtime::backend::AnyBackend;
-use mvm_runtime::vsock_transport;
 use mvm_vmm::host::shell::shell_quote;
+use mvm_vmm::vsock_transport;
 use serde::Deserialize;
 use std::collections::BTreeMap;
 use std::path::Path;
diff --git a/crates/mvm-cli/src/exec/guest_run.rs b/crates/mvm-cli/src/exec/guest_run.rs
index bd5143ea03..d77fa800c3 100644
--- a/crates/mvm-cli/src/exec/guest_run.rs
+++ b/crates/mvm-cli/src/exec/guest_run.rs
@@ -85,7 +85,7 @@ pub(super) fn run_in_guest(
     // Inbound vsock RPC audit. exec.rs is a top-level module that can't
     // reach the private `commands::shared` re-export, so inline the audit
     // emit here. The detail format matches
-    // `commands::shared::vsock::emit_vsock_rpc_audit`:
+    // `mvm_client::guest::emit_vsock_rpc_audit`:
     // `scope=rpc,direction=in,kind=vsock,verb=<kebab-name>`.
     mvm_core::audit_emit!(
         NetworkPolicyAllow,
diff --git a/crates/mvm-client/src/entrypoint/dispatch.rs b/crates/mvm-client/src/entrypoint/dispatch.rs
index 19fd21050f..2e338d7f25 100644
--- a/crates/mvm-client/src/entrypoint/dispatch.rs
+++ b/crates/mvm-client/src/entrypoint/dispatch.rs
@@ -438,7 +438,7 @@ fn dispatch_inner(
         timeout_secs,
         session_id: _,
     } = call;
-    let transport = mvm_runtime::vsock_transport::for_vm(vm_name)
+    let transport = mvm_vmm::vsock_transport::for_vm(vm_name)
         .with_context(|| format!("Picking transport for guest agent on '{vm_name}'"))?;
     let mut stream = transport
         .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
diff --git a/crates/mvm-client/src/entrypoint/session.rs b/crates/mvm-client/src/entrypoint/session.rs
index c5312a1314..0f12b2d93f 100644
--- a/crates/mvm-client/src/entrypoint/session.rs
+++ b/crates/mvm-client/src/entrypoint/session.rs
@@ -400,7 +400,7 @@ pub fn set_session_idle_timeout(raw_id: &str, secs: u64) -> Result<IdleTimeoutUp
 /// # Errors
 /// The agent unreachable, lacking the capability, or refusing the verb.
 pub fn update_idle_timeout(vm_name: &str, secs: u64) -> Result<(u64, u64)> {
-    let transport = mvm_runtime::vsock_transport::for_vm(vm_name)
+    let transport = mvm_vmm::vsock_transport::for_vm(vm_name)
         .with_context(|| format!("Picking transport for guest agent on {vm_name:?}"))?;
     let mut stream = transport
         .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
diff --git a/crates/mvm-client/src/guest.rs b/crates/mvm-client/src/guest.rs
index 625d44e19d..f671e2a95f 100644
--- a/crates/mvm-client/src/guest.rs
+++ b/crates/mvm-client/src/guest.rs
@@ -55,7 +55,7 @@ fn mock_agent_dir(name: &str) -> Option<String> {
 }
 
 fn connect(name: &str) -> Result<std::os::unix::net::UnixStream> {
-    mvm_runtime::vsock_transport::for_vm(name)?.connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
+    mvm_vmm::vsock_transport::for_vm(name)?.connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
 }
 
 /// Flush the guest only when the local machine is currently running.
diff --git a/crates/mvm-client/src/readiness.rs b/crates/mvm-client/src/readiness.rs
index 335be784d6..4694227b59 100644
--- a/crates/mvm-client/src/readiness.rs
+++ b/crates/mvm-client/src/readiness.rs
@@ -63,8 +63,8 @@ pub fn fetch_live_readiness(vm_name: &str) -> anyhow::Result<ReadinessReport> {
         GUEST_AGENT_PORT, GuestCapability, GuestRequest, GuestResponse, call_unary,
         negotiate_protocol,
     };
-    let transport: Box<dyn mvm_runtime::vsock_transport::VsockTransport> =
-        mvm_runtime::vsock_transport::for_vm(vm_name)?;
+    let transport: Box<dyn mvm_vmm::vsock_transport::VsockTransport> =
+        mvm_vmm::vsock_transport::for_vm(vm_name)?;
     let mut stream = transport.connect(GUEST_AGENT_PORT)?;
     let _ = negotiate_protocol(&mut stream, vec![GuestCapability::Readiness])?;
     match call_unary(&mut stream, &GuestRequest::ReadinessStatus)? {
@@ -89,7 +89,7 @@ pub fn wait_for_guest_agent(vm_id: &str, timeout_secs: u64) -> bool {
 /// Duration-based form used by launch policy and tests.
 pub fn wait_for_guest_agent_for(vm_id: &str, timeout: std::time::Duration) -> bool {
     wait_with_probe(timeout, |deadline, _remaining| {
-        let Ok(mut stream) = mvm_runtime::vsock_transport::connect_for_vm_before(
+        let Ok(mut stream) = mvm_vmm::vsock_transport::connect_for_vm_before(
             vm_id,
             mvm_agentd::vsock::GUEST_AGENT_PORT,
             deadline,
diff --git a/crates/mvm-client/src/vsock_transport.rs b/crates/mvm-client/src/vsock_transport.rs
index 55ead5c26d..c2f8bdb11a 100644
--- a/crates/mvm-client/src/vsock_transport.rs
+++ b/crates/mvm-client/src/vsock_transport.rs
@@ -1,3 +1,3 @@
 //! Vsock transports for the guest console. Pure re-exports.
 
-pub use mvm_runtime::vsock_transport::*;
+pub use mvm_vmm::vsock_transport::*;
diff --git a/crates/mvm-hostd/src/assurance_session.rs b/crates/mvm-hostd/src/assurance_session.rs
index 8d3748d379..cb0c7c4038 100644
--- a/crates/mvm-hostd/src/assurance_session.rs
+++ b/crates/mvm-hostd/src/assurance_session.rs
@@ -631,7 +631,7 @@ pub fn dispatch_ai_session(
         }
     }
 
-    let transport = mvm_runtime::vsock_transport::for_vm(vm)
+    let transport = mvm_vmm::vsock_transport::for_vm(vm)
         .with_context(|| format!("selecting extension transport for {vm}"))?;
     let mut stream = transport
         .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
@@ -754,7 +754,7 @@ pub fn cancel_ai_session(
         grant_digest: binding.grant.grant_digest.clone(),
         nonce: binding.grant.nonce.clone(),
     };
-    let transport = mvm_runtime::vsock_transport::for_vm(vm)
+    let transport = mvm_vmm::vsock_transport::for_vm(vm)
         .with_context(|| format!("selecting extension transport for {vm}"))?;
     let mut stream = transport
         .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
diff --git a/crates/mvm-hostd/src/drive.rs b/crates/mvm-hostd/src/drive.rs
index 50a3b1c608..c0841c73a7 100644
--- a/crates/mvm-hostd/src/drive.rs
+++ b/crates/mvm-hostd/src/drive.rs
@@ -176,7 +176,7 @@ impl DriveAuthority {
     {
         let call = self.prepare_open(cwd)?;
         let transport =
-            mvm_runtime::vsock_transport::for_vm(&self.vm).map_err(DriveSessionError::Rpc)?;
+            mvm_vmm::vsock_transport::for_vm(&self.vm).map_err(DriveSessionError::Rpc)?;
         let mut stream = transport
             .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
             .map_err(DriveSessionError::Rpc)?;
@@ -188,7 +188,7 @@ impl DriveAuthority {
     pub fn file(&self, operation: DriveFileOperation) -> Result<FsResult, DriveSessionError> {
         let operation = self.prepare_file(operation)?;
         let transport =
-            mvm_runtime::vsock_transport::for_vm(&self.vm).map_err(DriveSessionError::Rpc)?;
+            mvm_vmm::vsock_transport::for_vm(&self.vm).map_err(DriveSessionError::Rpc)?;
         let mut stream = transport
             .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
             .map_err(DriveSessionError::Rpc)?;
diff --git a/crates/mvm-hostd/src/health_probe.rs b/crates/mvm-hostd/src/health_probe.rs
index 02ed495780..b77d9306c1 100644
--- a/crates/mvm-hostd/src/health_probe.rs
+++ b/crates/mvm-hostd/src/health_probe.rs
@@ -64,7 +64,7 @@ pub struct AgentExec;
 
 impl GuestExec for AgentExec {
     fn exec(&self, vm_name: &str, cmd: &str, timeout_secs: u64) -> ExecOutcome {
-        let transport = match mvm_runtime::vsock_transport::for_vm(vm_name) {
+        let transport = match mvm_vmm::vsock_transport::for_vm(vm_name) {
             Ok(t) => t,
             Err(_) => return ExecOutcome::Unreachable,
         };
diff --git a/crates/mvm-hostd/src/stream/display_input_route.rs b/crates/mvm-hostd/src/stream/display_input_route.rs
index 3dd8f72e4d..f4c8a3b5c1 100644
--- a/crates/mvm-hostd/src/stream/display_input_route.rs
+++ b/crates/mvm-hostd/src/stream/display_input_route.rs
@@ -43,7 +43,7 @@ impl VsockDisplayInput {
 
 impl DisplayInputTransport for VsockDisplayInput {
     fn deliver(&mut self, frame: &DisplayInputFrame) -> Result<DisplayInputResult> {
-        let transport = mvm_runtime::vsock_transport::for_vm(&self.vm)
+        let transport = mvm_vmm::vsock_transport::for_vm(&self.vm)
             .with_context(|| format!("pick a transport for the guest agent on {:?}", self.vm))?;
         let mut stream = transport
             .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
diff --git a/crates/mvm-hostd/src/stream/input_route.rs b/crates/mvm-hostd/src/stream/input_route.rs
index 49f6e9ae2f..abeb92ed3d 100644
--- a/crates/mvm-hostd/src/stream/input_route.rs
+++ b/crates/mvm-hostd/src/stream/input_route.rs
@@ -483,7 +483,7 @@ impl VsockInput {
             &mut std::os::unix::net::UnixStream,
         ) -> Result<StreamInputResult, mvm_agentd::vsock::RpcError>,
     ) -> Result<()> {
-        let transport = mvm_runtime::vsock_transport::for_vm(&self.vm)
+        let transport = mvm_vmm::vsock_transport::for_vm(&self.vm)
             .with_context(|| format!("pick a transport for the guest agent on {:?}", self.vm))?;
         let mut stream = transport
             .connect(mvm_agentd::vsock::GUEST_AGENT_PORT)
diff --git a/crates/mvm-runtime/src/lib.rs b/crates/mvm-runtime/src/lib.rs
index 07d894a571..2007392e76 100644
--- a/crates/mvm-runtime/src/lib.rs
+++ b/crates/mvm-runtime/src/lib.rs
@@ -39,7 +39,6 @@ pub mod sdk_sidecar;
 pub mod security;
 pub mod storage;
 pub mod universal_initramfs;
-pub mod vsock_transport;
 
 pub mod vm;
 pub mod warm_artifact_builder;
diff --git a/crates/mvm-runtime/src/mock_guest_agent.rs b/crates/mvm-runtime/src/mock_guest_agent.rs
index a424489ae1..b73beb67fd 100644
--- a/crates/mvm-runtime/src/mock_guest_agent.rs
+++ b/crates/mvm-runtime/src/mock_guest_agent.rs
@@ -458,7 +458,7 @@ mod tests {
     use tempfile::TempDir;
 
     /// Connect a CONNECT-handshaked stream to a running mock agent —
-    /// the same shape `mvm::vsock_transport::for_vm(...).connect(...)`
+    /// the same shape `mvm_vmm::vsock_transport::for_vm(...).connect(...)`
     /// hands the backend-agnostic `*_on` helpers.
     fn connect_stream(dir: &TempDir) -> std::os::unix::net::UnixStream {
         connect_to(&vsock_uds_path(&dir.path().to_string_lossy()), 5).expect("connect mock stream")
diff --git a/crates/mvm-runtime/src/storage/volume/backend.rs b/crates/mvm-runtime/src/storage/volume/backend.rs
deleted file mode 100644
index b85f5bf8bc..0000000000
--- a/crates/mvm-runtime/src/storage/volume/backend.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Canonical backend trait re-exported from the dependency-light contract crate.
-
-pub use mvm_contract::{VolumeBackend, VolumeFuture};
diff --git a/crates/mvm-runtime/src/storage/volume/contract.rs b/crates/mvm-runtime/src/storage/volume/contract.rs
deleted file mode 100644
index 360452167d..0000000000
--- a/crates/mvm-runtime/src/storage/volume/contract.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Canonical backend contract fixture re-exported for runtime consumers.
-
-pub use mvm_contract::contract::assert_backend_contract;
diff --git a/crates/mvm-runtime/src/storage/volume/local.rs b/crates/mvm-runtime/src/storage/volume/local.rs
deleted file mode 100644
index 8880519ef0..0000000000
--- a/crates/mvm-runtime/src/storage/volume/local.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Canonical local backend re-exported from the volume contract crate.
-
-pub use mvm_contract::LocalBackend;
diff --git a/crates/mvm-runtime/src/storage/volume/mod.rs b/crates/mvm-runtime/src/storage/volume/mod.rs
index 5471587019..9bf65d703a 100644
--- a/crates/mvm-runtime/src/storage/volume/mod.rs
+++ b/crates/mvm-runtime/src/storage/volume/mod.rs
@@ -19,10 +19,7 @@
 //! concurrent put/get) against any [`VolumeBackend`] impl. mvmd
 //! re-uses it for `ObjectStoreBackend` and `EncryptedBackend<B>`.
 
-pub mod backend;
 pub mod content_addressed;
-pub mod contract;
-pub mod local;
 pub mod mount_provider;
 pub mod provider;
 
@@ -36,12 +33,12 @@ pub mod encrypted;
 #[path = "encrypted_linux.rs"]
 pub mod encrypted;
 
-pub use backend::{VolumeBackend, VolumeFuture};
 pub use content_addressed::{ContentAddressedStore, ContentDigest};
-pub use local::LocalBackend;
 pub use mount_provider::{
     HostPathFs, MountError, MountProvider, MountRegistry, Mountable, TmpfsFs, VolumeFs,
 };
+pub use mvm_contract::contract;
+pub use mvm_contract::{LocalBackend, VolumeBackend, VolumeFuture};
 pub use provider::{AttachedVolume, LocalStorage, StorageProvider, VolumeHandle, VolumeSpec};
 
 pub use encrypted::EncryptedStorage;
diff --git a/crates/mvm-runtime/src/vm/lease.rs b/crates/mvm-runtime/src/vm/lease.rs
index dca0160454..5028b40c57 100644
--- a/crates/mvm-runtime/src/vm/lease.rs
+++ b/crates/mvm-runtime/src/vm/lease.rs
@@ -20,7 +20,7 @@ use mvm_core::vm_backend::{
     StandbyClaim, StandbyCompat, VmBackend, VmId, WarmClaimRefusal, WarmLaunchMode,
 };
 
-use crate::vsock_transport::{self, VsockTransport};
+use mvm_vmm::vsock_transport::{self, VsockTransport};
 
 /// What a lease needs to claim (or cold-boot) a warm VM.
 pub struct AcquireSpec {
diff --git a/crates/mvm-runtime/src/vsock_transport.rs b/crates/mvm-runtime/src/vsock_transport.rs
deleted file mode 100644
index d7bd4a41a1..0000000000
--- a/crates/mvm-runtime/src/vsock_transport.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//! Backend-agnostic vsock connect dispatch re-exported from `mvm-vmm`.
-//!
-//! The implementation now lives in `mvm-vmm::vsock_transport`; `mvm-runtime`
-//! re-exports the public surface at the old path until downstream callers are
-//! migrated.
-
-pub use mvm_vmm::vsock_transport::*;
diff --git a/crates/mvm-sdk/src/decorator/mod.rs b/crates/mvm-sdk/src/decorator/mod.rs
deleted file mode 100644
index c3a7729080..0000000000
--- a/crates/mvm-sdk/src/decorator/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! Compatibility facade — the decorator parser now lives in `mvm-compiler`.
-//!
-//! All types and parsers are re-exported unchanged so existing
-//! `mvm_sdk::decorator` paths keep working.
-
-pub use mvm_compiler::decorator::python;
-pub use mvm_compiler::decorator::typescript;
-pub use mvm_compiler::decorator::value;
-pub use mvm_compiler::decorator::*;
diff --git a/crates/mvm-sdk/src/lib.rs b/crates/mvm-sdk/src/lib.rs
index 729a7eeeb2..eb510514ab 100644
--- a/crates/mvm-sdk/src/lib.rs
+++ b/crates/mvm-sdk/src/lib.rs
@@ -84,12 +84,6 @@ pub mod addon;
 #[cfg(feature = "compiler")]
 pub mod compile;
 
-/// Static decorator parser — extracts `@mvm.app(...)` kwargs from a
-/// user's Python or TypeScript source file and lowers them to a
-/// `Workload` IR. Pure tree-sitter; never imports the user's code.
-/// Closed `mvm.*` helper allowlist; non-literal kwargs rejected.
-pub mod decorator;
-
 /// Deploy-bundle assembly and local attestation for mvmd-owned control-plane
 /// flows. Builds the single `.tar.gz` (compile output plus embedded
 /// `mvmd-spec.json`) and exposes the authenticated shipping seam.
diff --git a/scripts/check-no-orchestration-server.sh b/scripts/check-no-orchestration-server.sh
index a149b7239b..7c4c26f093 100755
--- a/scripts/check-no-orchestration-server.sh
+++ b/scripts/check-no-orchestration-server.sh
@@ -94,7 +94,6 @@ candidates=$(rg \
   --glob '!**/examples/**' \
   --glob '!**/fuzz/**' \
   --glob '!crates/mvm-build/src/egress_proxy/**' \
-  --glob '!crates/mvm-cli/src/commands/shared/vsock.rs' \
   --glob '!crates/mvm-cli/src/commands/vm/forward.rs' \
   --glob '!crates/mvm-cli/src/commands/vm/display.rs' \
   --glob '!crates/mvm-cli/src/metrics_server.rs' \
diff --git a/specs/adrs/014-signed-audited-execution-plans.md b/specs/adrs/014-signed-audited-execution-plans.md
index bb43a62f16..f9eb0a6ddb 100644
--- a/specs/adrs/014-signed-audited-execution-plans.md
+++ b/specs/adrs/014-signed-audited-execution-plans.md
@@ -39,7 +39,7 @@ mvmctl machine run <image|flake|manifest>
   │     │     ├── sign_plan + verify_plan (roundtrip)
   │     │     ├── check_window (validity)
   │     │     └── nonce_store.check_and_insert (replay)
-  │     └── AuditEmitter::emit_admitted(...)        [crates/mvm-cli/src/commands/vm/audit_chain.rs]
+  │     └── AuditEmitter::emit_admitted(...)        [crates/mvm-hostd/src/audit/emitter.rs]
   │           appends a signed envelope to ~/.mvm/audit/<tenant>.jsonl
   │
   ├── backend.start(&start_config)                  [mvm-runtime::AnyBackend]
diff --git a/tests/runtime_boot_bench.rs b/tests/runtime_boot_bench.rs
index c0e4b6d82c..6ffb62a968 100644
--- a/tests/runtime_boot_bench.rs
+++ b/tests/runtime_boot_bench.rs
@@ -64,7 +64,7 @@ use anyhow::{Context, Result, bail};
 use mvm_agentd::vsock::{GuestRequest, GuestResponse};
 use mvm_core::vm_backend::VmStartConfig;
 use mvm_runtime::backend::AnyBackend;
-use mvm_runtime::vsock_transport::VsockTransport as _;
+use mvm_vmm::vsock_transport::VsockTransport as _;
 use serde::Deserialize;
 
 #[path = "runtime_boot_evidence/mod.rs"]
@@ -944,7 +944,7 @@ fn wait_for_guest_agent(backend: &str, name: &str) -> Result<()> {
 }
 
 fn wait_for_hvf_guest_agent(name: &str) -> Result<()> {
-    let transport = mvm_runtime::vsock_transport::HvfVsockTransport::for_vm(name);
+    let transport = mvm_vmm::vsock_transport::HvfVsockTransport::for_vm(name);
     let deadline = Instant::now() + READY_TIMEOUT;
     let mut last_err = None;