@@ -29,3 +29,12 @@ morphis-voice = { path = "../morphis-voice" }
 morphis-llm = { path = "../morphis-llm" }
 morphis-memory = { path = "../morphis-memory" }
 morphis-sandbox = { path = "../morphis-sandbox" }
+
+# `morphis skills install --url <url>` — download tarball + verify sha256.
+# reqwest comes from the workspace's existing TLS tree (morphis-llm already
+# pulled it in); sha2 / tar / flate2 are leaf crates.
+reqwest = { workspace = true }
+sha2 = "0.10"
+tar = "0.4"
+flate2 = "1.0"
+tempfile = "3.13"
@@ -80,11 +80,22 @@ enum Command {
 
 #[derive(Subcommand, Debug)]
 enum SkillsAction {
-    /// Install a skill from a local directory.
+    /// Install a skill from a local directory or a downloadable tarball.
     Install {
         /// Path to the skill directory (must contain SKILL.md + manifest.yaml).
+        /// Mutually exclusive with --url.
+        #[arg(long, conflicts_with = "url", required_unless_present = "url")]
+        local: Option<std::path::PathBuf>,
+        /// URL of a .tar.gz containing the skill at its root (i.e. manifest.yaml
+        /// sits at the top of the archive, not under a subdir).
+        /// Requires --sha256.
+        #[arg(long, requires = "sha256")]
+        url: Option<String>,
+        /// Hex sha256 of the bytes returned by --url. V0.5 always requires
+        /// integrity verification — no plain HTTP downloads land without a
+        /// declared checksum.
         #[arg(long)]
-        local: std::path::PathBuf,
+        sha256: Option<String>,
     },
     /// Remove an installed skill by name.
     Uninstall {
@@ -174,7 +185,16 @@ fn main() -> anyhow::Result<()> {
                 VoiceAction::Test => run_voice_test().await?,
             },
             Command::Skills { action } => match action {
-                SkillsAction::Install { local } => run_skills_install(&local).await?,
+                SkillsAction::Install { local, url, sha256 } => match (local, url) {
+                    (Some(path), None) => run_skills_install_local(&path).await?,
+                    (None, Some(url)) => {
+                        let hash = sha256.ok_or_else(|| {
+                            anyhow::anyhow!("--url requires --sha256 for integrity check")
+                        })?;
+                        run_skills_install_url(&url, &hash).await?;
+                    }
+                    _ => anyhow::bail!("specify exactly one of --local or --url"),
+                },
                 SkillsAction::Uninstall { name } => run_skills_uninstall(&name).await?,
                 SkillsAction::List => run_skills_list().await?,
             },
@@ -283,7 +303,7 @@ async fn build_llm_router() -> anyhow::Result<Arc<dyn LLMProvider>> {
     Ok(Arc::new(router))
 }
 
-async fn run_skills_install(src: &std::path::Path) -> anyhow::Result<()> {
+async fn run_skills_install_local(src: &std::path::Path) -> anyhow::Result<()> {
     let store = SkillStore::default_for_user()?;
     let skill = store.install_local(src).await?;
     println!(
@@ -295,6 +315,87 @@ async fn run_skills_install(src: &std::path::Path) -> anyhow::Result<()> {
     Ok(())
 }
 
+async fn run_skills_install_url(url: &str, expected_sha256: &str) -> anyhow::Result<()> {
+    let bytes = download_to_bytes(url).await?;
+    verify_sha256(&bytes, expected_sha256)?;
+    let staging = tempfile::tempdir()?;
+    extract_tar_gz(&bytes, staging.path())?;
+    let skill_root = locate_skill_root(staging.path())?;
+    let store = SkillStore::default_for_user()?;
+    let skill = store.install_local(&skill_root).await?;
+    println!(
+        "installed {} v{} at {} (from {url})",
+        skill.name(),
+        skill.version(),
+        skill.root.display()
+    );
+    Ok(())
+}
+
+async fn download_to_bytes(url: &str) -> anyhow::Result<Vec<u8>> {
+    let resp = reqwest::get(url).await?;
+    let status = resp.status();
+    if !status.is_success() {
+        anyhow::bail!("download {url}: HTTP {status}");
+    }
+    let bytes = resp.bytes().await?;
+    Ok(bytes.to_vec())
+}
+
+fn verify_sha256(bytes: &[u8], expected_hex: &str) -> anyhow::Result<()> {
+    use sha2::{Digest, Sha256};
+    let mut hasher = Sha256::new();
+    hasher.update(bytes);
+    let got = hasher.finalize();
+    let got_hex = hex_encode(&got);
+    let expected_lc = expected_hex.trim().to_ascii_lowercase();
+    if got_hex != expected_lc {
+        anyhow::bail!("sha256 mismatch: declared {expected_lc} but downloaded bytes are {got_hex}");
+    }
+    Ok(())
+}
+
+fn hex_encode(bytes: &[u8]) -> String {
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        out.push_str(&format!("{b:02x}"));
+    }
+    out
+}
+
+fn extract_tar_gz(bytes: &[u8], dest: &std::path::Path) -> anyhow::Result<()> {
+    let gz = flate2::read::GzDecoder::new(bytes);
+    let mut archive = tar::Archive::new(gz);
+    archive.set_preserve_permissions(false);
+    archive.set_overwrite(true);
+    archive.unpack(dest)?;
+    Ok(())
+}
+
+/// The downloaded tarball may have the skill at its root OR under a single
+/// top-level directory (the cargo-package convention). We accept either: if
+/// `dest/manifest.yaml` exists, that's the root; else, if there is exactly one
+/// subdirectory and it contains manifest.yaml, use that. Anything else is a
+/// malformed archive.
+fn locate_skill_root(dest: &std::path::Path) -> anyhow::Result<std::path::PathBuf> {
+    if dest.join("manifest.yaml").is_file() {
+        return Ok(dest.to_path_buf());
+    }
+    let mut subdirs: Vec<std::path::PathBuf> = Vec::new();
+    for entry in std::fs::read_dir(dest)? {
+        let entry = entry?;
+        if entry.file_type()?.is_dir() {
+            subdirs.push(entry.path());
+        }
+    }
+    if subdirs.len() == 1 && subdirs[0].join("manifest.yaml").is_file() {
+        return Ok(subdirs.into_iter().next().unwrap());
+    }
+    anyhow::bail!(
+        "downloaded tarball doesn't contain manifest.yaml at root or under a single subdir"
+    )
+}
+
 async fn run_skills_uninstall(name: &str) -> anyhow::Result<()> {
     let store = SkillStore::default_for_user()?;
     let removed = store.uninstall(name).await?;
@@ -334,3 +435,89 @@ async fn run_voice_test() -> anyhow::Result<()> {
     );
     Ok(())
 }
+
+#[cfg(test)]
+mod skill_install_url_tests {
+    use super::*;
+    use flate2::write::GzEncoder;
+    use flate2::Compression;
+
+    fn build_tar_gz(entries: &[(&str, &[u8])]) -> Vec<u8> {
+        let mut gz = GzEncoder::new(Vec::new(), Compression::default());
+        {
+            let mut tar = tar::Builder::new(&mut gz);
+            for (name, body) in entries {
+                let mut header = tar::Header::new_gnu();
+                header.set_size(body.len() as u64);
+                header.set_mode(0o644);
+                header.set_cksum();
+                tar.append_data(&mut header, name, *body).unwrap();
+            }
+            tar.finish().unwrap();
+        }
+        gz.finish().unwrap()
+    }
+
+    #[test]
+    fn verify_sha256_accepts_matching_hash() {
+        let bytes = b"morphis skill bytes";
+        // sha256(b"morphis skill bytes"):
+        use sha2::{Digest, Sha256};
+        let mut h = Sha256::new();
+        h.update(bytes);
+        let hex = hex_encode(&h.finalize());
+        assert!(verify_sha256(bytes, &hex).is_ok());
+        // Case insensitivity + whitespace trim.
+        let upper = format!("  {}  ", hex.to_uppercase());
+        assert!(verify_sha256(bytes, &upper).is_ok());
+    }
+
+    #[test]
+    fn verify_sha256_rejects_mismatch() {
+        let err = verify_sha256(b"x", "deadbeef").unwrap_err();
+        assert!(err.to_string().contains("sha256 mismatch"));
+    }
+
+    #[test]
+    fn extract_tar_gz_unpacks_a_skill_at_archive_root() {
+        let dir = tempfile::tempdir().unwrap();
+        let bytes = build_tar_gz(&[
+            (
+                "manifest.yaml",
+                b"name: from-url\nversion: 0.1.0\nsandbox: wasmtime\n",
+            ),
+            ("SKILL.md", b"# from-url\nfrom-url body\n"),
+        ]);
+        extract_tar_gz(&bytes, dir.path()).unwrap();
+        assert!(dir.path().join("manifest.yaml").is_file());
+        assert!(dir.path().join("SKILL.md").is_file());
+    }
+
+    #[test]
+    fn locate_skill_root_finds_root_manifest() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("manifest.yaml"), "name: x").unwrap();
+        let root = locate_skill_root(dir.path()).unwrap();
+        assert_eq!(root, dir.path());
+    }
+
+    #[test]
+    fn locate_skill_root_finds_single_subdir_manifest() {
+        let dir = tempfile::tempdir().unwrap();
+        let sub = dir.path().join("inner-skill");
+        std::fs::create_dir_all(&sub).unwrap();
+        std::fs::write(sub.join("manifest.yaml"), "name: y").unwrap();
+        let root = locate_skill_root(dir.path()).unwrap();
+        assert_eq!(root, sub);
+    }
+
+    #[test]
+    fn locate_skill_root_errors_when_archive_is_malformed() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join("a")).unwrap();
+        std::fs::create_dir_all(dir.path().join("b")).unwrap();
+        // Two subdirs, no root manifest, neither has manifest.yaml — refuse.
+        let err = locate_skill_root(dir.path()).unwrap_err();
+        assert!(err.to_string().contains("doesn't contain manifest.yaml"));
+    }
+}