skippy: land Laguna Q4 and experimental Inkling split serving

.github/workflows/queue-unsloth-layer-packages.yml

@@ -31,7 +31,7 @@ on:
         required: false
         default: "main"
       quant_preference:
-        description: "Comma-separated 4-bit quant preference"
+        description: "Comma-separated quant preference"
         required: false
         default: "UD-Q4_K_XL,UD-Q4_K_M,Q4_K_XL,Q4_K_M"
       split_candidate_vram_gib:
@@ -64,6 +64,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5.1.0
+        with:
+          persist-credentials: false
 
       - uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4 # stable 2026-07-16
 

Justfile

@@ -266,11 +266,15 @@ skippy-quantize-release-build:
 # llama.cpp quantization ABI linked into the executable.
 [unix]
 skippy-quantize-standalone-build backend="cpu":
-    LLAMA_STAGE_BACKEND="{{ backend }}" LLAMA_STAGE_LINK_MODE=static just with-lld cargo build -p skippy-quantize
+    scripts/prepare-llama.sh pinned
+    LLAMA_STAGE_BACKEND="{{ backend }}" LLAMA_STAGE_LINK_MODE=static scripts/build-llama.sh
+    LLAMA_STAGE_BACKEND="{{ backend }}" LLAMA_STAGE_LINK_MODE=static just with-lld cargo build -p skippy-quantize --no-default-features
 
 [unix]
 skippy-quantize-standalone-release-build backend="cpu":
-    LLAMA_STAGE_BACKEND="{{ backend }}" LLAMA_STAGE_LINK_MODE=static just with-lld cargo build --release --locked -p skippy-quantize
+    scripts/prepare-llama.sh pinned
+    LLAMA_STAGE_BACKEND="{{ backend }}" LLAMA_STAGE_LINK_MODE=static scripts/build-llama.sh
+    LLAMA_STAGE_BACKEND="{{ backend }}" LLAMA_STAGE_LINK_MODE=static just with-lld cargo build --release --locked -p skippy-quantize --no-default-features
 
 # Generate a reproducible benchmark corpus for skippy bench tooling.
 bench-corpus tier="smoke" *ARGS="":

crates/llama-quant-ffi/src/lib.rs

@@ -38,6 +38,7 @@ pub enum LlamaFileType {
     MostlyMxfp4Moe = 38,
     MostlyNvfp4 = 39,
     MostlyQ1_0 = 40,
+    MostlyQ2_0 = 41,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/mesh-llm-cli/src/models.rs

@@ -39,6 +39,9 @@ pub enum ModelsCommand {
         /// Branch or tag of mesh-llm to build in the job.
         #[arg(long, default_value = "main")]
         mesh_llm_ref: String,
+        /// Publish a public package marked experimental and open an unmerged HF catalog PR.
+        #[arg(long)]
+        experimental: bool,
         /// Explicitly keep this as a dry run. This is the default unless --confirm is set.
         #[arg(long)]
         dry_run: bool,

crates/mesh-llm-cli/src/parser.rs

@@ -98,7 +98,8 @@ pub fn assert_mesh_requirements_docs_examples_parse() {
 
 #[cfg(test)]
 mod tests {
-    use super::Cli;
+    use super::{Cli, Command};
+    use crate::models::ModelsCommand;
     use clap::Parser;
 
     #[test]
@@ -138,4 +139,29 @@ mod tests {
             Some(std::path::PathBuf::from("topology.json"))
         );
     }
+
+    #[test]
+    fn models_package_parses_experimental_publication() {
+        let cli = Cli::parse_from([
+            "mesh-llm",
+            "models",
+            "package",
+            "unsloth/inkling-GGUF:UD-Q2_K_XL",
+            "--experimental",
+            "--dry-run",
+        ]);
+
+        match cli.command.expect("models command expected") {
+            Command::Models {
+                command:
+                    ModelsCommand::Package {
+                        source_repo: Some(source_repo),
+                        experimental: true,
+                        dry_run: true,
+                        ..
+                    },
+            } => assert_eq!(source_repo, "unsloth/inkling-GGUF:UD-Q2_K_XL"),
+            other => panic!("unexpected command: {other:?}"),
+        }
+    }
 }

crates/mesh-llm-commands/src/model_package.rs

@@ -3,7 +3,7 @@ use tokio_stream::StreamExt;
 
 use ::model_package::jobs::HfJobsClient;
 use ::model_package::permissions;
-use ::model_package::prepare::{self, DiscoveredQuant, PrepareParams};
+use ::model_package::prepare::{self, DiscoveredQuant, PrepareJob, PrepareParams};
 use ::model_package::script;
 use serde_json::json;
 
@@ -16,6 +16,7 @@ pub struct ModelPrepareArgs<'a> {
     pub flavor: &'a str,
     pub timeout: &'a str,
     pub mesh_llm_ref: &'a str,
+    pub experimental: bool,
     pub dry_run: bool,
     pub confirm: bool,
     pub follow: bool,
@@ -37,6 +38,7 @@ pub async fn dispatch_model_package(args: ModelPrepareArgs<'_>) -> Result<()> {
         flavor,
         timeout,
         mesh_llm_ref,
+        experimental,
         dry_run,
         confirm,
         follow,
@@ -95,7 +97,13 @@ pub async fn dispatch_model_package(args: ModelPrepareArgs<'_>) -> Result<()> {
     // If no quant specified, list available quants and exit.
     // This path doesn't need HF_TOKEN — works for public repos.
     if source_quant.is_none() {
-        return run_list_quants(&hf_client, source_repo, json).await;
+        return run_list_quants(
+            &hf_client,
+            source_repo,
+            source_model_ref.revision.as_deref(),
+            json,
+        )
+        .await;
     }
 
     let submitting = confirm && !dry_run;
@@ -116,71 +124,22 @@ pub async fn dispatch_model_package(args: ModelPrepareArgs<'_>) -> Result<()> {
     eprintln!("🔍 Resolving source...");
     let params = PrepareParams {
         source_repo: source_repo.to_string(),
+        source_revision: source_model_ref.revision.clone(),
         quant: source_quant.map(|s| s.to_string()),
         target: target.map(|s| s.to_string()),
         model_id: model_id.map(|s| s.to_string()),
         flavor: flavor.to_string(),
         timeout_seconds,
         mesh_llm_ref: mesh_llm_ref.to_string(),
+        experimental,
         hf_token: jobs_client
             .as_ref()
             .map(|client| client.token().to_string()),
     };
 
     let job = prepare::resolve(&hf_client, params, &perms).await?;
 
-    // Print resolved info.
-    let shard_info = model_ref::split_gguf_shard_info(&job.source_file);
-    let shard_str = if let Some(shard) = shard_info {
-        format!(" ({} shards)", shard.total)
-    } else {
-        String::new()
-    };
-
-    eprintln!("   Repo:   {}", job.source_repo);
-    eprintln!("   File:   {}{}", job.source_file, shard_str);
-    eprintln!();
-    eprintln!(
-        "🔑 Permissions: {} ({})",
-        perms.username,
-        if perms.is_meshllm_member {
-            "meshllm org member"
-        } else {
-            "not in meshllm org"
-        }
-    );
-    eprintln!("   Target:  {}", job.target_repo);
-    eprintln!(
-        "   Catalog: meshllm/catalog ({})",
-        if job.catalog_create_pr {
-            "will open PR"
-        } else {
-            "direct commit"
-        }
-    );
-    eprintln!();
-    eprintln!(
-        "📋 Job: {}, timeout {}, mesh-llm@{}",
-        job.spec.flavor,
-        format_timeout(job.spec.timeout_seconds),
-        job.spec
-            .environment
-            .get("MESH_LLM_REF")
-            .map(|s| s.as_str())
-            .unwrap_or("main")
-    );
-    eprintln!(
-        "   Hardware: {} {} ({})",
-        job.job_plan.pretty_name,
-        hardware_label(job.job_plan.cpu.as_deref(), job.job_plan.ram.as_deref()),
-        job.job_plan.selection_reason
-    );
-    eprintln!(
-        "   Pricing:  ${:.6}/{}, max {}",
-        job.job_plan.unit_cost_usd,
-        job.job_plan.unit_label,
-        format_cost(job.job_plan.max_cost_usd)
-    );
+    print_prepare_job(&job, &perms);
 
     if !submitting {
         let redacted = redacted_spec(&job.spec);
@@ -191,9 +150,12 @@ pub async fn dispatch_model_package(args: ModelPrepareArgs<'_>) -> Result<()> {
                     "dryRun": true,
                     "confirmRequired": true,
                     "sourceRepo": job.source_repo,
+                    "sourceRevision": job.source_revision,
                     "sourceFile": job.source_file,
+                    "projectors": job.projectors,
                     "targetRepo": job.target_repo,
                     "modelId": job.model_id,
+                    "experimental": job.experimental,
                     "jobPlan": job.job_plan,
                     "spec": redacted,
                 }))?
@@ -232,9 +194,12 @@ pub async fn dispatch_model_package(args: ModelPrepareArgs<'_>) -> Result<()> {
                 "jobUrl": job_url,
                 "namespace": job.namespace,
                 "sourceRepo": job.source_repo,
+                "sourceRevision": job.source_revision,
                 "sourceFile": job.source_file,
+                "projectors": job.projectors,
                 "targetRepo": job.target_repo,
                 "modelId": job.model_id,
+                "experimental": job.experimental,
                 "jobPlan": job.job_plan,
             }))?
         );
@@ -251,19 +216,89 @@ pub async fn dispatch_model_package(args: ModelPrepareArgs<'_>) -> Result<()> {
     Ok(())
 }
 
+fn print_prepare_job(job: &PrepareJob, perms: &permissions::PermissionCheck) {
+    let shard_info = model_ref::split_gguf_shard_info(&job.source_file);
+    let shard_str = if let Some(shard) = shard_info {
+        format!(" ({} shards)", shard.total)
+    } else {
+        String::new()
+    };
+
+    eprintln!("   Repo:   {}", job.source_repo);
+    eprintln!("   Commit: {}", job.source_revision);
+    eprintln!("   File:   {}{}", job.source_file, shard_str);
+    for projector in &job.projectors {
+        eprintln!("   MMProj: {}", projector.path);
+    }
+    eprintln!();
+    eprintln!(
+        "🔑 Permissions: {} ({})",
+        perms.username,
+        if perms.is_meshllm_member {
+            "meshllm org member"
+        } else {
+            "not in meshllm org"
+        }
+    );
+    eprintln!("   Target:  {}", job.target_repo);
+    eprintln!(
+        "   Release: {}",
+        if job.experimental {
+            "experimental (public, not cataloged until HF PR merge)"
+        } else {
+            "stable"
+        }
+    );
+    eprintln!(
+        "   Catalog: meshllm/catalog ({})",
+        if job.catalog_create_pr {
+            "will open PR"
+        } else {
+            "direct commit"
+        }
+    );
+    eprintln!();
+    eprintln!(
+        "📋 Job: {}, timeout {}, mesh-llm@{}",
+        job.spec.flavor,
+        format_timeout(job.spec.timeout_seconds),
+        job.spec
+            .environment
+            .get("MESH_LLM_REF")
+            .map(|s| s.as_str())
+            .unwrap_or("main")
+    );
+    eprintln!(
+        "   Hardware: {} {} ({})",
+        job.job_plan.pretty_name,
+        hardware_label(job.job_plan.cpu.as_deref(), job.job_plan.ram.as_deref()),
+        job.job_plan.selection_reason
+    );
+    eprintln!(
+        "   Pricing:  ${:.6}/{}, max {}",
+        job.job_plan.unit_cost_usd,
+        job.job_plan.unit_label,
+        format_cost(job.job_plan.max_cost_usd)
+    );
+}
+
 async fn run_list_quants(
     client: &hf_hub::HFClient,
     source_repo: &str,
+    source_revision: Option<&str>,
     json_output: bool,
 ) -> Result<()> {
-    let quants = prepare::list_quants(client, source_repo).await?;
+    let inventory = prepare::list_inventory(client, source_repo, source_revision).await?;
+    let quants = inventory.quants;
 
     if json_output {
         println!(
             "{}",
             serde_json::to_string_pretty(&json!({
                 "sourceRepo": source_repo,
+                "sourceRevision": source_revision,
                 "quants": quants,
+                "projectors": inventory.projectors,
             }))?
         );
         return Ok(());
@@ -280,13 +315,20 @@ async fn run_list_quants(
     eprintln!();
     eprintln!("Specify one as a model ref, e.g.:");
     eprintln!(
-        "   mesh-llm models package {}:{}",
-        source_repo, quants[0].name
+        "   mesh-llm models package {}",
+        source_quant_ref(source_repo, source_revision, &quants[0].name)
     );
 
     Ok(())
 }
 
+fn source_quant_ref(source_repo: &str, source_revision: Option<&str>, quant: &str) -> String {
+    source_revision.map_or_else(
+        || format!("{source_repo}:{quant}"),
+        |revision| format!("{source_repo}@{revision}:{quant}"),
+    )
+}
+
 fn print_quant_table(quants: &[DiscoveredQuant]) {
     // Find the longest name for alignment.
     let max_name = quants.iter().map(|q| q.name.len()).max().unwrap_or(0);
@@ -639,4 +681,20 @@ mod tests {
     fn parse_timeout_mixed() {
         assert_eq!(parse_timeout("1h30m45s").unwrap(), 5445);
     }
+
+    #[test]
+    fn source_quant_ref_preserves_revision() {
+        assert_eq!(
+            source_quant_ref("poolside/Laguna-S-2.1-GGUF", Some("abc123"), "Q4_K_M"),
+            "poolside/Laguna-S-2.1-GGUF@abc123:Q4_K_M"
+        );
+    }
+
+    #[test]
+    fn source_quant_ref_omits_absent_revision() {
+        assert_eq!(
+            source_quant_ref("poolside/Laguna-S-2.1-GGUF", None, "Q4_K_M"),
+            "poolside/Laguna-S-2.1-GGUF:Q4_K_M"
+        );
+    }
 }