release(0.70): batch-1 — 9 receipted rows, one CI run, one queue slot

Cargo.toml

@@ -624,6 +624,14 @@ gates = [
     # silence. RED when evidence/perf041/<host>/marker.json is absent, is not
     # PASS, or is older than perf-matrix.yaml `witness.max_age_days`.
     "scripts/check_perf041_marker.sh",
+    # #3076: apr's F16/BF16 CPU matvec against the pinned llama.cpp, greedy, on the
+    # template-free models its committed receipts name (evidence/pmat-3076-f16-bf16-matvec/).
+    # A model absent from the release host is a FAIL. This list is
+    # [package.metadata.dogfood].gates: only `scripts/dogfood.sh --phase pre-publish`
+    # executes it, at release time, on the host that has the models. Nothing on the PR path
+    # runs this entry. The PR-time half, the comparison helpers' case table, is
+    # scripts/check_float16_greedy_parity.sh, which guard_tree.sh dispatches.
+    "scripts/float16_greedy_parity.sh",
 ]
 
 # The interfaces this release SHIPS, each paired with the e2e target that proves

crates/apr-cli/src/commands/hex.rs

@@ -116,6 +116,19 @@ fn format_display_name(fmt: FileFormat) -> &'static str {
     }
 }
 
+/// The format a model file's magic bytes identify, for an error message:
+/// "APR", "GGUF", "SafeTensors", or "model" when they identify none or the
+/// file cannot be read (#3661). Reads at most 9 bytes.
+pub(crate) fn detected_model_format(path: &Path) -> &'static str {
+    use std::io::Read;
+    let mut head = Vec::with_capacity(9);
+    let read = std::fs::File::open(path).and_then(|f| f.take(9).read_to_end(&mut head));
+    match read {
+        Ok(_) => detect_format(&head).map_or("model", format_display_name),
+        Err(_) => "model",
+    }
+}
+
 // ============================================================================
 // Main entry point
 // ============================================================================

crates/apr-cli/src/commands/inference_output.rs

@@ -327,7 +327,8 @@ fn execute_with_realizar(
         .with_top_p(options.top_p)
         .with_seed(options.seed)
         .with_repeat_penalty(options.repeat_penalty)
-        .with_repeat_last_n(options.repeat_last_n);
+        .with_repeat_last_n(options.repeat_last_n)
+        .with_force_chat_template(options.chat_template);
 
     if options.no_gpu {
         config = config.without_gpu();

crates/apr-cli/src/commands/inspect.rs

@@ -378,7 +378,7 @@ fn run_rosetta_inspect(
     let rosetta = RosettaStone::new();
     let report = rosetta
         .inspect(path)
-        .map_err(|e| CliError::InvalidFormat(format!("Inspection failed: {e}")))?;
+        .map_err(|e| CliError::invalid_model_file(path, "Inspection failed", &e))?;
 
     if json_output {
         output_rosetta_json(path, &report);

crates/apr-cli/src/commands/mod.rs

@@ -106,6 +106,9 @@ pub(crate) mod mcp;
 pub(crate) mod merge;
 #[cfg(feature = "training")]
 pub(crate) mod model_config;
+// #3661: a model parse failure names the format its magic bytes identify.
+#[cfg(test)]
+mod model_file_error_tests_3661;
 #[cfg(feature = "training")]
 pub(crate) mod monitor;
 #[cfg(feature = "dev")]

crates/apr-cli/src/commands/model_file_error_tests_3661.rs

@@ -0,0 +1,143 @@
+//! #3661: a model file that fails to parse is named by what its magic bytes say it is.
+//!
+//! `CliError::InvalidFormat` Displays "Invalid APR format", and `apr inspect` and
+//! `apr tensors` wrapped every parse failure in it, so a truncated GGUF was reported
+//! as an invalid APR file. Each row drives the real command function and renders the
+//! error exactly as `apr` prints it (`error: {e}`, main.rs), then checks three things:
+//! the format the message names, exit code 4, and that the core error's
+//! "Invalid model format:" prefix never appears under the CLI's own.
+
+use crate::commands::{inspect, tensors};
+use crate::error::CliError;
+use std::path::{Path, PathBuf};
+
+/// A GGUF written by aprender's own exporter, cut off inside its metadata.
+/// That is the issue's input: a real GGUF truncated mid-header.
+fn truncated_gguf(dir: &Path) -> PathBuf {
+    use aprender::format::gguf::{export_tensors_to_gguf, GgmlType, GgufTensor, GgufValue};
+    let tensors = vec![GgufTensor {
+        name: "token_embd.weight".to_string(),
+        shape: vec![4, 8],
+        dtype: GgmlType::F32,
+        data: vec![0u8; 4 * 8 * 4],
+    }];
+    let metadata = vec![
+        (
+            "general.architecture".to_string(),
+            GgufValue::String("llama".to_string()),
+        ),
+        (
+            "general.name".to_string(),
+            GgufValue::String("truncated-3661".to_string()),
+        ),
+    ];
+    let mut bytes = Vec::new();
+    export_tensors_to_gguf(&mut bytes, &tensors, &metadata).expect("write GGUF");
+    // 24 bytes of fixed header (magic, version, two counts), then the first key's u64
+    // length: cut 4 bytes into it, so the reader hits the issue's own failure,
+    // "Unexpected EOF reading u64".
+    let path = dir.join("t.gguf");
+    std::fs::write(&path, &bytes[..28]).expect("write truncated GGUF");
+    path
+}
+
+/// 4 KiB of noise named `.safetensors`, opening with the issue's own magic bytes
+/// (`8e44f12f`). Its first u64 is far past any real header length, so no format matches.
+fn random_safetensors(dir: &Path) -> PathBuf {
+    let mut state: u32 = 0x3661;
+    let mut bytes: Vec<u8> = vec![0x8e, 0x44, 0xf1, 0x2f, 0x9d, 0x27, 0x6b, 0xb3];
+    while bytes.len() < 4096 {
+        state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
+        bytes.push((state >> 24) as u8);
+    }
+    let path = dir.join("t.safetensors");
+    std::fs::write(&path, &bytes).expect("write random bytes");
+    path
+}
+
+/// A real APR v2 file cut to 32 bytes, less than its 64-byte header.
+fn truncated_apr(dir: &Path) -> PathBuf {
+    use aprender::format::v2::{AprV2Metadata, AprV2Writer};
+    let mut writer = AprV2Writer::new(AprV2Metadata::new("truncated-3661"));
+    writer.add_f32_tensor("w", vec![2, 2], &[0.0, 1.0, 2.0, 3.0]);
+    let bytes = writer.write().expect("write APR v2");
+    let path = dir.join("t.apr");
+    std::fs::write(&path, &bytes[..32]).expect("write truncated APR");
+    path
+}
+
+fn inspect_err(path: &Path) -> CliError {
+    inspect::run(path, false, false, false, false, false).expect_err("inspect must refuse")
+}
+
+fn tensors_err(path: &Path) -> CliError {
+    tensors::run(path, false, None, false, 0).expect_err("tensors must refuse")
+}
+
+#[test]
+fn a_parse_failure_names_the_format_the_magic_bytes_identify() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let gguf = truncated_gguf(dir.path());
+    let st = random_safetensors(dir.path());
+    let apr = truncated_apr(dir.path());
+
+    // (row, the error, the prefix the rendered line must start with)
+    let rows: Vec<(&str, CliError, &str)> = vec![
+        (
+            "inspect truncated GGUF",
+            inspect_err(&gguf),
+            "error: Invalid GGUF file: ",
+        ),
+        (
+            "tensors truncated GGUF",
+            tensors_err(&gguf),
+            "error: Invalid GGUF file: ",
+        ),
+        (
+            "inspect random .safetensors",
+            inspect_err(&st),
+            "error: Invalid model file: ",
+        ),
+        (
+            "tensors random .safetensors",
+            tensors_err(&st),
+            "error: Invalid model file: ",
+        ),
+        // A truncated .apr still says APR, so the fix is not "delete the word".
+        (
+            "inspect truncated APR",
+            inspect_err(&apr),
+            "error: Invalid APR ",
+        ),
+        (
+            "tensors truncated APR",
+            tensors_err(&apr),
+            "error: Invalid APR file: ",
+        ),
+    ];
+
+    let mut failures = Vec::new();
+    for (row, err, want_prefix) in &rows {
+        let rendered = format!("error: {err}");
+        let is_apr = want_prefix.starts_with("error: Invalid APR");
+        if !rendered.starts_with(want_prefix) {
+            failures.push(format!("{row}: wanted `{want_prefix}…`, got `{rendered}`"));
+        }
+        if !is_apr && rendered.contains("Invalid APR") {
+            failures.push(format!("{row}: calls a non-APR file APR: `{rendered}`"));
+        }
+        if rendered.contains("Invalid model format") {
+            failures.push(format!(
+                "{row}: the core prefix leaked under the CLI's: `{rendered}`"
+            ));
+        }
+        if err.exit_code_value() != 4 {
+            failures.push(format!("{row}: exit {} (wanted 4)", err.exit_code_value()));
+        }
+    }
+    assert!(
+        failures.is_empty(),
+        "#3661 rows failed:\n{}",
+        failures.join("\n")
+    );
+}

crates/apr-cli/src/commands/profile_safetensors.rs

@@ -29,7 +29,7 @@ fn profile_safetensors_real(
     let rosetta = aprender::format::rosetta::RosettaStone::new();
     let report = rosetta
         .inspect(path)
-        .map_err(|e| CliError::InvalidFormat(format!("Inspection failed: {e}")))?;
+        .map_err(|e| CliError::invalid_model_file(path, "Inspection failed", &e))?;
 
     let num_layers = report
         .tensors

crates/apr-cli/src/commands/run.rs

@@ -169,6 +169,9 @@ pub(crate) struct RunOptions {
     pub repeat_last_n: usize,
     /// Process prompt tokens one-by-one (debug prefill)
     pub split_prompt: bool,
+    /// #3672: apply the model's chat template (`--chat`, or an instruct/chat source name)
+    /// even when its metadata and file name say base model. The prompt itself stays raw.
+    pub chat_template: bool,
     /// `--stream`: emit one NDJSON event per generated token.
     ///
     /// Known here (not only at the print site) because streaming is the one
@@ -202,6 +205,7 @@ impl Default for RunOptions {
             repeat_penalty: 1.0,
             repeat_last_n: 64,
             split_prompt: false,
+            chat_template: false,
             stream: false,
         }
     }

crates/apr-cli/src/commands/run_entry.rs

@@ -42,6 +42,8 @@ pub(crate) fn run(
     repeat_penalty: f32,
     repeat_last_n: usize,
     split_prompt: bool,
+    // #3672: apply the model's chat template once, in realizar; the prompt is raw text.
+    chat_template: bool,
 ) -> Result<()> {
     // GH-516: Warn on --language/--task since whisper integration is not yet wired up
     if language.is_some() {
@@ -105,6 +107,7 @@ pub(crate) fn run(
         repeat_penalty,
         repeat_last_n,
         split_prompt,
+        chat_template,
         stream,
     };
 

crates/apr-cli/src/commands/serve/chat.rs

@@ -74,8 +74,14 @@ pub(crate) fn load_safetensors_tokenizer(path: &Path) -> Option<SafeTensorsToken
     let mut vocab = vocab;
     let (bos_token_id, eos_token_id) = merge_special_tokens_into_vocab(added_tokens, &mut vocab);
 
-    // Create BPE tokenizer with vocab and merge rules
-    let tokenizer = realizar::tokenizer::BPETokenizer::new(vocab.clone(), merges, "<unk>").ok()?;
+    // Create BPE tokenizer with vocab and merge rules. #3609: the unknown token is the one
+    // tokenizer.json DECLARES (`model.unk_token`, null for byte-level models like Qwen),
+    // not a literal "<unk>" every model is assumed to have.
+    let unk_token = json
+        .get("model")
+        .and_then(|m| m.get("unk_token"))
+        .and_then(|v| v.as_str());
+    let tokenizer = realizar::tokenizer::BPETokenizer::new(vocab.clone(), merges, unk_token).ok()?;
 
     Some(SafeTensorsTokenizerInfo {
         tokenizer: std::sync::Arc::new(tokenizer),

crates/apr-cli/src/commands/serve/handler_gpu_completion.rs

@@ -418,7 +418,7 @@ fn start_gguf_server(model_path: &Path, config: &ServerConfig) -> Result<()> {
         .green()
     );
 
-    let vocab = extract_gguf_vocab(&mapped_model, quantized_model.config().vocab_size);
+    let vocab = extract_gguf_vocab(&mapped_model)?;
 
     // PERF-021 / N4 / I-2: a request has a RESOLUTION, and it is reported.
     //
@@ -463,26 +463,27 @@ fn start_gguf_server(model_path: &Path, config: &ServerConfig) -> Result<()> {
     run_cpu_server(quantized_model, vocab, Some(mapped_model), config, Some(offload))
 }
 
-/// Extract vocabulary from GGUF model, falling back to placeholder tokens.
+/// Extract the vocabulary from a GGUF model, or refuse to serve it (#3609).
 ///
-/// GH-226: When the GGUF lacks `tokenizer.ggml.tokens` metadata, the placeholder
-/// vocabulary must include `<unk>` so that `BPETokenizer::new` can find it.
-/// Without this, the serve path fails with "Unknown token '<unk>' not in vocabulary"
-/// and the server exits before binding — causing "Server failed to become ready".
-fn extract_gguf_vocab(
-    mapped_model: &realizar::gguf::MappedGGUFModel,
-    vocab_size: usize,
-) -> Vec<String> {
-    mapped_model.model.vocabulary().unwrap_or_else(|| {
-        eprintln!("Warning: No vocabulary in GGUF, using placeholder tokens");
-        let mut vocab: Vec<String> = (0..vocab_size).map(|i| format!("token{i}")).collect();
-        // GH-226: Ensure <unk> is present for BPETokenizer compatibility.
-        // Use slot 0 (standard convention for unknown token).
-        if !vocab.is_empty() {
-            vocab[0] = "<unk>".to_string();
-        }
-        vocab
-    })
+/// GH-226 once filled a missing `tokenizer.ggml.tokens` with `token0..tokenN` and put
+/// `<unk>` in slot 0, because `BPETokenizer::new` required one. So a model with NO
+/// vocabulary loaded, while a model with a real vocabulary that lacked `<unk>` (Qwen3.5)
+/// was refused: the less-specified input was the one accepted. The unknown token is
+/// now optional, and a model with no vocabulary refuses by name. Placeholder tokens
+/// are not a tokenizer.
+fn extract_gguf_vocab(mapped_model: &realizar::gguf::MappedGGUFModel) -> Result<Vec<String>> {
+    mapped_model
+        .model
+        .vocabulary()
+        .ok_or_else(|| no_vocabulary("the GGUF (no tokenizer.ggml.tokens)"))
+}
+
+/// #3609: the refusal every serve path gives for a model with no vocabulary.
+fn no_vocabulary(what: &str) -> CliError {
+    CliError::ModelLoadFailed(format!(
+        "{what} has no vocabulary to tokenize with, so there is nothing to serve; \
+         refusing to substitute placeholder tokens (#3609)"
+    ))
 }
 
 /// #2762: resolve the KV-cache context length for the GGUF + CUDA serve path.
@@ -651,7 +652,7 @@ fn start_gguf_server_cuda(
             let quantized_model = OwnedQuantizedModel::from_mapped(&mapped_model).map_err(|e| {
                 CliError::ModelLoadFailed(format!("Failed to rebuild quantized model: {e}"))
             })?;
-            let vocab = extract_gguf_vocab(&mapped_model, quantized_model.config().vocab_size);
+            let vocab = extract_gguf_vocab(&mapped_model)?;
             // CUDA init failed and this process fell back to CPU. The offload
             // report travels with it UNCHANGED, so `/v1/effective-config` shows
             // `gpu_layers_resolved` beside `backend_loaded: ["cpu"]` — which is

crates/apr-cli/src/commands/serve/handlers.rs

@@ -594,16 +594,13 @@ fn wgpu_smoke_test(
 }
 
 /// PMAT-340: Extract the real vocab from the GGUF for tokenize/detokenize.
+/// #3609: a GGUF with no vocabulary refuses by name (see `extract_gguf_vocab`).
 #[cfg(feature = "wgpu")]
-fn wgpu_vocabulary(mapped: &realizar::gguf::MappedGGUFModel, vocab_size: usize) -> Vec<String> {
-    mapped.model.vocabulary().unwrap_or_else(|| {
-        eprintln!("Warning: No vocabulary in GGUF, using placeholder");
-        let mut v: Vec<String> = (0..vocab_size).map(|i| format!("token{i}")).collect();
-        if !v.is_empty() {
-            v[0] = "<unk>".to_string();
-        }
-        v
-    })
+fn wgpu_vocabulary(mapped: &realizar::gguf::MappedGGUFModel) -> Result<Vec<String>> {
+    mapped
+        .model
+        .vocabulary()
+        .ok_or_else(|| no_vocabulary("the GGUF (no tokenizer.ggml.tokens)"))
 }
 
 /// PMAT-341: Build a BPE tokenizer from the GGUF merge rules.
@@ -822,7 +819,7 @@ fn serve_wgpu_backend(
     println!("{}", "Starting WGPU inference server...".cyan());
 
     // PMAT-340: Extract real vocab from GGUF for tokenization/detokenization
-    let vocab = wgpu_vocabulary(mapped, vocab_size);
+    let vocab = wgpu_vocabulary(mapped)?;
     // PMAT-341: Extract BPE merge rules for proper tokenization
     let merges = mapped.model.merge_rules().unwrap_or_default();
     println!(
@@ -1443,15 +1440,7 @@ fn try_apr_quantized_cpu(model_path: &Path, config: &ServerConfig) -> Result<()>
     let vocab = mapped
         .metadata
         .get_embedded_vocabulary()
-        .unwrap_or_else(|| {
-            let vocab_size = mapped.metadata.vocab_size.unwrap_or(32000);
-            eprintln!("Warning: No embedded vocabulary in APR, using placeholder tokens");
-            let mut v: Vec<String> = (0..vocab_size).map(|i| format!("token{i}")).collect();
-            if !v.is_empty() {
-                v[0] = "<unk>".to_string();
-            }
-            v
-        });
+        .ok_or_else(|| no_vocabulary("the APR file (no embedded vocabulary)"))?;
 
     println!("{}", "Q4K CPU inference ready".green());