@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.3-beta.3

package/src/services/manifest/manifest.test.ts

@@ -0,0 +1,791 @@
+import { describe, expect, it } from "vitest";
+import {
+	canSetAsDefault,
+	ELIZA_1_MANIFEST_SCHEMA_VERSION,
+	ELIZA_1_TIERS,
+	ELIZA_1_TOKENIZER_FAMILY,
+	REQUIRED_KERNELS_BY_TIER,
+	validateManifest,
+} from "./index";
+import type { Eliza1DeviceCaps, Eliza1Manifest, Eliza1Tier } from "./types";
+
+const SHA = "0".repeat(64);
+const VISION_TIERS = new Set<Eliza1Tier>(["2b", "4b", "9b", "27b", "27b-256k"]);
+const MTP_TIERS = new Set<Eliza1Tier>(["2b", "4b", "9b", "27b", "27b-256k"]);
+
+function passingBackends() {
+	return {
+		metal: {
+			status: "pass" as const,
+			atCommit: "abc1234",
+			report: "metal.txt",
+		},
+		vulkan: {
+			status: "pass" as const,
+			atCommit: "abc1234",
+			report: "vulkan.txt",
+		},
+		cuda: { status: "pass" as const, atCommit: "abc1234", report: "cuda.txt" },
+		rocm: { status: "pass" as const, atCommit: "abc1234", report: "rocm.txt" },
+		cpu: { status: "pass" as const, atCommit: "abc1234", report: "cpu.txt" },
+	};
+}
+
+function textFileForTier(tier: Eliza1Tier): { path: string; ctx: number } {
+	return { path: `text/eliza-1-${tier}-128k.gguf`, ctx: 131072 };
+}
+
+function baseManifest(tier: Eliza1Tier = "9b"): Eliza1Manifest {
+	const hasVision = VISION_TIERS.has(tier);
+	const hasMtp = MTP_TIERS.has(tier);
+	const manifest: Eliza1Manifest = {
+		id: `eliza-1-${tier}`,
+		tier,
+		version: "1.0.0",
+		publishedAt: "2026-05-10T00:00:00Z",
+		lineage: {
+			text: { base: "eliza-1-text-backbone", license: "apache-2.0" },
+			voice: { base: "eliza-1-voice-backbone", license: "apache-2.0" },
+			asr: { base: "eliza-1-asr", license: "apache-2.0" },
+			vad: { base: "eliza-1-vad", license: "apache-2.0" },
+		},
+		files: {
+			text: [{ ...textFileForTier(tier), sha256: SHA }],
+			voice: [{ path: "tts/omnivoice-base-Q4_K_M.gguf", sha256: SHA }],
+			asr: [{ path: "asr/asr.gguf", sha256: SHA }],
+			vision: [],
+			mtp: [],
+			cache: [{ path: "cache/voice-preset-default.bin", sha256: SHA }],
+			vad: [{ path: "vad/silero-vad-v5.gguf", sha256: SHA }],
+		},
+		kernels: {
+			required: [...REQUIRED_KERNELS_BY_TIER[tier]],
+			optional: [],
+			verifiedBackends: passingBackends(),
+		},
+		evals: {
+			textEval: { score: 0.71, passed: true },
+			voiceRtf: { rtf: 0.42, passed: true },
+			asrWer: { wer: 0.05, passed: true },
+			vadLatencyMs: {
+				median: 16,
+				boundaryMs: 24,
+				endpointMs: 80,
+				falseBargeInRate: 0.01,
+				passed: true,
+			},
+			e2eLoopOk: true,
+			thirtyTurnOk: true,
+		},
+		ramBudgetMb: { min: 7000, recommended: 9500 },
+		defaultEligible: true,
+	};
+	if (hasVision) {
+		manifest.lineage.vision = {
+			base: "eliza-1-vision",
+			license: "apache-2.0",
+		};
+		manifest.files.vision = [
+			{ path: `vision/mmproj-${tier}.gguf`, sha256: SHA },
+		];
+	}
+	if (hasMtp) {
+		manifest.evals.mtp = { acceptanceRate: 0.72, speedup: 1.8, passed: true };
+		// Gemma 4 separate-drafter MTP: every MTP tier bundles its drafter GGUF
+		// at `mtp/drafter-<tier>.gguf` with its own lineage and declares the mode.
+		manifest.files.mtp = [{ path: `mtp/drafter-${tier}.gguf`, sha256: SHA }];
+		manifest.lineage.drafter = {
+			base: "eliza-1-drafter",
+			license: "apache-2.0",
+		};
+		manifest.mtp = "separate-drafter";
+	}
+	return manifest;
+}
+
+describe("Eliza-1 manifest schema constants", () => {
+	it("exports schema version 1", () => {
+		expect(ELIZA_1_MANIFEST_SCHEMA_VERSION).toBe("1");
+	});
+
+	it("uses Eliza-1 size-tier ids and tokenizer family", () => {
+		expect(ELIZA_1_TOKENIZER_FAMILY).toBe("gemma4");
+		expect(ELIZA_1_TIERS).toEqual(["2b", "4b", "9b", "27b", "27b-256k"]);
+		expect(Object.keys(REQUIRED_KERNELS_BY_TIER)).toEqual(
+			expect.arrayContaining(["2b", "4b"]),
+		);
+		// Gemma 4 cutover: the only REQUIRED kernel is the geometry-agnostic
+		// turboquant_q4 weight-quant. The KV-cache kernels (qjl/polarquant/
+		// turbo3_tcq) are head_dim=128-coupled and OPTIONAL for Gemma's stock
+		// q8_0 KV path.
+		for (const tier of ELIZA_1_TIERS) {
+			expect(REQUIRED_KERNELS_BY_TIER[tier]).toEqual(["turboquant_q4"]);
+			expect(REQUIRED_KERNELS_BY_TIER[tier]).not.toContain("turbo3_tcq");
+		}
+	});
+});
+
+describe("validateManifest — valid input", () => {
+	it("accepts a fully-populated, default-eligible manifest", () => {
+		const result = validateManifest(baseManifest());
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.manifest.tier).toBe("9b");
+			expect(result.manifest.defaultEligible).toBe(true);
+			expect(result.manifest.evals.vadLatencyMs?.falseBargeInRate).toBe(0.01);
+		}
+	});
+
+	it("keeps legacy ONNX VAD manifests compatible", () => {
+		const m = baseManifest();
+		m.files.vad = [{ path: "vad/silero-vad-int8.onnx", sha256: SHA }];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("keeps the canonical bundled VAD artifact on GGUF for every tier", () => {
+		for (const tier of ELIZA_1_TIERS) {
+			expect(baseManifest(tier).files.vad?.[0]?.path).toBe(
+				"vad/silero-vad-v5.gguf",
+			);
+		}
+	});
+
+	it("accepts optional component lineage, files, evals, and voice capabilities", () => {
+		const m = baseManifest();
+		m.lineage.embedding = { base: "eliza-1-embedding", license: "apache-2.0" };
+		m.lineage.imagegen = {
+			base: "eliza-1-imagegen",
+			license: "pending-license-review",
+		};
+		m.lineage.wakeword = { base: "eliza-1-wakeword", license: "apache-2.0" };
+		m.files.embedding = [{ path: "embedding/eliza-1-embed.gguf", sha256: SHA }];
+		m.files.imagegen = [{ path: "imagegen/sd-1.5-Q5_0.gguf", sha256: SHA }];
+		m.files.wakeword = [{ path: "wakeword/eliza-1.onnx", sha256: SHA }];
+		m.voice = {
+			version: "1",
+			frozen: true,
+			cache: {
+				speakerPreset: "cache/voice-preset-default.bin",
+				phraseCacheSeed: "cache/voice-preset-default.bin",
+			},
+			capabilities: ["tts", "emotion-tags"],
+		};
+		m.evals.embedMteb = { score: 0.62, passed: true };
+		m.evals.expressive = {
+			tagFaithfulness: 0.9,
+			mosExpressive: 4.1,
+			tagLeakage: 0.01,
+			passed: true,
+		};
+
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("accepts optional specDecode kernel and eval metadata without requiring it by tier", () => {
+		const m = baseManifest("2b");
+		m.kernels.specDecode = {
+			enabled: true,
+			capability: "spec-decode",
+			specType: "draft-mtp",
+			model: "mtp/drafter-2b.gguf",
+			maxDraftTokens: 15,
+		};
+		m.evals.specDecode = {
+			acceptanceRate: 0.64,
+			speedup: 1.35,
+			passed: true,
+		};
+
+		const result = validateManifest(m);
+		expect([...REQUIRED_KERNELS_BY_TIER["2b"]] as string[]).not.toContain(
+			"specDecode",
+		);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.manifest.kernels.specDecode?.capability).toBe(
+				"spec-decode",
+			);
+			expect(result.manifest.evals.specDecode?.speedup).toBe(1.35);
+		}
+	});
+
+	it("accepts the back-compat eagle3 alias for specDecode metadata", () => {
+		const m = baseManifest("2b");
+		m.kernels.eagle3 = {
+			enabled: true,
+			capability: "eagle3",
+			specType: "draft-eagle3",
+			model: "RedHatAI/gemma-4-E2B-EAGLE3-head",
+			maxDraftTokens: 3,
+		};
+		m.evals.eagle3 = {
+			acceptanceRate: 0.64,
+			speedup: 1.35,
+			passed: true,
+		};
+
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.manifest.kernels.eagle3?.capability).toBe("eagle3");
+			expect(result.manifest.evals.eagle3?.speedup).toBe(1.35);
+		}
+	});
+
+	it("accepts optional specDecode failure metadata without affecting default eligibility", () => {
+		const m = baseManifest("9b");
+		m.kernels.specDecode = {
+			enabled: false,
+			failure: "not available in this build",
+		};
+		m.evals.specDecode = {
+			acceptanceRate: null,
+			speedup: null,
+			passed: false,
+			failure: "not run on a spec-decode-capable runtime",
+		};
+
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("accepts every tier with that tier's required kernel set", () => {
+		for (const tier of ELIZA_1_TIERS) {
+			const m = baseManifest(tier);
+			const result = validateManifest(m);
+			const detail = result.ok ? "" : ` errors=${result.errors.join(", ")}`;
+			expect(result.ok, `${tier} should validate.${detail}`).toBe(true);
+		}
+	});
+
+	it("represents vision on every active tier", () => {
+		for (const tier of ELIZA_1_TIERS) {
+			const m = baseManifest(tier);
+			expect(m.files.vision).toEqual([
+				{ path: `vision/mmproj-${tier}.gguf`, sha256: SHA },
+			]);
+			expect(m.lineage.vision).toEqual({
+				base: "eliza-1-vision",
+				license: "apache-2.0",
+			});
+			expect(validateManifest(m).ok).toBe(true);
+		}
+	});
+});
+
+describe("validateManifest — schema-level rejections", () => {
+	it("rejects a manifest with a bad sha256", () => {
+		const m = baseManifest();
+		m.files.text[0].sha256 = "not-a-hash";
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects out-of-range VAD false barge-in metrics", () => {
+		const m = baseManifest();
+		m.evals.vadLatencyMs = {
+			median: 16,
+			falseBargeInRate: 1.2,
+			passed: true,
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects out-of-range specDecode eval metrics", () => {
+		const m = baseManifest() as unknown as Record<string, unknown>;
+		(m.evals as Record<string, unknown>).specDecode = {
+			acceptanceRate: 1.2,
+			speedup: 1.35,
+			passed: false,
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects a passing specDecode eval without measured numbers", () => {
+		const m = baseManifest();
+		m.evals.specDecode = { speedup: null, passed: true };
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("evals.specDecode"))).toBe(
+				true,
+			);
+		}
+	});
+
+	it("rejects invalid known specDecode kernel metadata fields", () => {
+		const m = baseManifest() as unknown as Record<string, unknown>;
+		(m.kernels as Record<string, unknown>).specDecode = {
+			specType: "",
+			maxDraftTokens: 0,
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects an unknown tier", () => {
+		const m = baseManifest() as unknown as Record<string, unknown>;
+		m.tier = "ultra-99b";
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects bad semver", () => {
+		const m = baseManifest();
+		(m as Record<string, unknown>).version = "v1";
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects publishedAt with a timezone offset (Zod parity with Python)", () => {
+		// The Python validator's _DATETIME_RE matches Zod's `.datetime()`
+		// default — only `Z` suffix is accepted, no offsets. Keeping the
+		// two sides in lockstep prevents drift between training-side
+		// build_manifest output and runtime-side validation.
+		const m = baseManifest();
+		m.publishedAt = "2026-05-10T00:00:00+00:00";
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects an id that does not encode the tier", () => {
+		const m = baseManifest();
+		m.id = "eliza-1-foo";
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+});
+
+describe("validateManifest — contract rejections", () => {
+	it("rejects a manifest missing a required kernel for its tier", () => {
+		const m = baseManifest("9b");
+		// Gemma required set is turboquant_q4; drop it (leaving only optional
+		// KV kernels) to trip the missing-required-kernel check.
+		m.kernels.required = ["qjl", "polarquant"];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("turboquant_q4"))).toBe(true);
+		}
+	});
+
+	it("rejects defaultEligible=true when textEval did not pass", () => {
+		const m = baseManifest();
+		m.evals.textEval.passed = false;
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("textEval"))).toBe(true);
+			expect(result.errors.some((e) => e.includes("defaultEligible"))).toBe(
+				true,
+			);
+		}
+	});
+
+	it("rejects defaultEligible=true when voiceRtf did not pass", () => {
+		const m = baseManifest();
+		m.evals.voiceRtf.passed = false;
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects defaultEligible=true when e2eLoopOk is false", () => {
+		const m = baseManifest();
+		m.evals.e2eLoopOk = false;
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+	});
+
+	it("rejects a passing MTP eval without measured numbers", () => {
+		const m = baseManifest();
+		m.evals.mtp = { acceptanceRate: null, speedup: null, passed: true };
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("evals.mtp.passed"))).toBe(
+				true,
+			);
+		}
+	});
+
+	it("rejects strict releases when MTP eval did not pass", () => {
+		const m = baseManifest();
+		m.evals.mtp = { acceptanceRate: 0.5, speedup: null, passed: false };
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("evals.mtp.passed"))).toBe(
+				true,
+			);
+		}
+	});
+
+	it("accepts a separate-drafter MTP bundle (drafter GGUF + lineage present)", () => {
+		const m = baseManifest("9b");
+		m.mtp = "separate-drafter";
+		m.lineage.drafter = {
+			base: "eliza-1-mtp-drafter",
+			license: "apache-2.0",
+		};
+		m.files.mtp = [{ path: "mtp/drafter-9b.gguf", sha256: SHA }];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("rejects a strict-release MTP tier that omits the bundled drafter", () => {
+		const m = baseManifest("9b");
+		m.files.mtp = [];
+		m.lineage.drafter = undefined;
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(
+				result.errors.some((e) => e.includes("MTP drafter not bundled")),
+			).toBe(true);
+		}
+	});
+
+	it("rejects an MTP drafter bundled at the legacy dflash/ path", () => {
+		const m = baseManifest("9b");
+		m.files.mtp = [{ path: "dflash/drafter-9b.gguf", sha256: SHA }];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(
+				result.errors.some((e) => e.includes("must bundle the drafter at")),
+			).toBe(true);
+		}
+	});
+
+	it("rejects component files without matching lineage and eval gates", () => {
+		const m = baseManifest();
+		m.lineage.asr = undefined;
+		m.evals.asrWer = undefined;
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("lineage.asr"))).toBe(true);
+			expect(result.errors.some((e) => e.includes("evals.asrWer"))).toBe(true);
+		}
+	});
+
+	it("rejects defaultEligible=true when ASR or VAD are absent", () => {
+		const m = baseManifest();
+		m.files.asr = [];
+		m.files.vad = [];
+		m.lineage.asr = undefined;
+		m.lineage.vad = undefined;
+		m.evals.asrWer = undefined;
+		m.evals.vadLatencyMs = undefined;
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("files.asr"))).toBe(true);
+			expect(result.errors.some((e) => e.includes("files.vad"))).toBe(true);
+		}
+	});
+
+	it("rejects strict/defaultEligible Qwen ASR provenance", () => {
+		const m = baseManifest();
+		m.lineage.asr = {
+			base: "ggml-org/Qwen3-ASR-0.6B",
+			license: "apache-2.0",
+		};
+		m.provenance = {
+			releaseState: "base-v1",
+			finetuned: false,
+			sourceModels: {
+				text: { repo: "google/gemma-4-12B-base" },
+				voice: { repo: "Serveurperso/OmniVoice-GGUF" },
+				drafter: { repo: "elizaos/eliza-1" },
+				asr: { repo: "ggml-org/Qwen3-ASR-GGUF" },
+				embedding: { repo: "google/gemma-4-12B-base" },
+				imagegen: { repo: "elizaos/eliza-1-imagegen" },
+				vad: { repo: "onnx-community/silero-vad" },
+				vision: { repo: "unsloth/gemma-4-12B-GGUF" },
+			},
+		};
+
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors).toEqual(
+				expect.arrayContaining([
+					expect.stringContaining("lineage.asr.base"),
+					expect.stringContaining("provenance.sourceModels.asr.repo"),
+				]),
+			);
+		}
+	});
+
+	it("rejects expressive voice capabilities without expressive eval", () => {
+		const m = baseManifest();
+		m.voice = {
+			version: "1",
+			frozen: true,
+			cache: {
+				speakerPreset: "cache/voice-preset-default.bin",
+				phraseCacheSeed: "cache/voice-preset-default.bin",
+			},
+			capabilities: ["tts", "singing"],
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("evals.expressive"))).toBe(
+				true,
+			);
+		}
+	});
+
+	it("rejects defaultEligible=true when a supported backend did not pass", () => {
+		const m = baseManifest("9b");
+		m.kernels.verifiedBackends.cuda = {
+			status: "fail",
+			atCommit: "abc1234",
+			report: "cuda.txt",
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("cuda"))).toBe(true);
+		}
+	});
+
+	it("does not require cuda or rocm for tiers that don't ship on cuda/rocm", () => {
+		const m = baseManifest("2b");
+		// 2B (entry tier) doesn't ship on cuda/rocm; failures there should not block.
+		m.kernels.verifiedBackends.cuda = {
+			status: "fail",
+			atCommit: "abc1234",
+			report: "cuda.txt",
+		};
+		m.kernels.verifiedBackends.rocm = {
+			status: "fail",
+			atCommit: "abc1234",
+			report: "rocm.txt",
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("requires rocm for desktop and server tiers", () => {
+		const m = baseManifest("9b");
+		m.kernels.verifiedBackends.rocm = {
+			status: "fail",
+			atCommit: "abc1234",
+			report: "rocm.txt",
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("rocm"))).toBe(true);
+		}
+	});
+
+	// (Removed: "requires turbo3_tcq when text ctx > 64k" — Gemma 4 handles
+	// long context with native windowed-SWA + shared-KV at stock q8_0, so
+	// turbo3_tcq is no longer a required long-context kernel.)
+
+	it("rejects text GGUFs below the 128k floor", () => {
+		const m = baseManifest("2b");
+		m.files.text = [
+			{ path: "text/eliza-1-2b-64k.gguf", ctx: 65536, sha256: SHA },
+		];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("128k"))).toBe(true);
+		}
+	});
+
+	it("accepts turbo3_tcq as optional-only when ctx > 64k", () => {
+		const m = baseManifest("9b");
+		m.files.text[0].ctx = 131072;
+		// Gemma 4: turbo3_tcq is an optional KV accelerator, not required for
+		// long context — a 128k bundle that lists it only under `optional`
+		// (stock q8_0 KV) is contract-valid.
+		m.kernels.required = m.kernels.required.filter((k) => k !== "turbo3_tcq");
+		m.kernels.optional = ["turbo3_tcq"];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.errors ?? []).toEqual([]);
+		} else {
+			expect(result.errors.some((e) => e.includes("kernels.required"))).toBe(
+				false,
+			);
+		}
+	});
+
+	it("accepts turbo3_tcq in required when ctx > 64k", () => {
+		const m = baseManifest("9b");
+		m.files.text[0].ctx = 131072;
+		m.kernels.optional = [];
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("rejects missing vision artifacts on every active tier", () => {
+		for (const tier of ELIZA_1_TIERS) {
+			const m = baseManifest(tier);
+			m.files.vision = [];
+			m.lineage.vision = undefined;
+			const result = validateManifest(m);
+			expect(result.ok).toBe(false);
+			if (!result.ok) {
+				expect(result.errors.some((e) => e.includes("files.vision"))).toBe(
+					true,
+				);
+			}
+		}
+	});
+
+	it("accepts vision artifacts on the 2B mobile entry tier", () => {
+		expect(validateManifest(baseManifest("2b")).ok).toBe(true);
+	});
+});
+
+describe("canSetAsDefault", () => {
+	const device: Eliza1DeviceCaps = {
+		availableBackends: ["metal", "cpu"],
+		ramMb: 32_000,
+	};
+
+	it("returns true for a default-eligible bundle on a supported backend", () => {
+		expect(canSetAsDefault(baseManifest("9b"), device)).toBe(true);
+	});
+
+	it("returns true for a contract-valid candidate bundle on a supported backend", () => {
+		// A `base-v1-candidate` manifest with every backend verified pass and
+		// every eval green is still contract-valid — it is just not the strict
+		// release. The on-device gate accepts it as the auto-default fallback
+		// when no `defaultEligible: true` bundle is installed; the recommender
+		// is the layer that prefers a strict release when both are present.
+		const m = baseManifest("9b");
+		m.defaultEligible = false;
+		m.provenance = {
+			releaseState: "base-v1-candidate",
+			finetuned: false,
+			sourceModels: {
+				text: { repo: "google/gemma-4-12B-base" },
+				voice: { repo: "Serveurperso/OmniVoice-GGUF" },
+				drafter: { repo: "elizaos/eliza-1" },
+				asr: { repo: "ggml-org/Qwen3-ASR-GGUF" },
+				embedding: { repo: "Qwen/Qwen3-Embedding-GGUF" },
+				vad: { repo: "onnx-community/silero-vad" },
+				vision: { repo: "unsloth/gemma-4-12B-GGUF" },
+			},
+		};
+		expect(canSetAsDefault(m, device)).toBe(true);
+	});
+
+	it("returns false when device RAM is below the manifest minimum", () => {
+		const m = baseManifest("9b");
+		expect(canSetAsDefault(m, { ...device, ramMb: 4_000 })).toBe(false);
+	});
+
+	it("returns false when the device shares no passing backend with the tier", () => {
+		const m = baseManifest("27b");
+		m.kernels.verifiedBackends.metal = {
+			status: "fail",
+			atCommit: "abc1234",
+			report: "metal.txt",
+		};
+		expect(
+			canSetAsDefault(m, { availableBackends: ["metal"], ramMb: 64_000 }),
+		).toBe(false);
+	});
+
+	it("returns false when the manifest fails contract checks even if defaultEligible=true", () => {
+		const m = baseManifest("9b");
+		// Drop the required Gemma weight-quant kernel to fail the contract.
+		m.kernels.required = ["qjl", "polarquant"];
+		expect(canSetAsDefault(m, device)).toBe(false);
+	});
+
+	it("does not auto-default version-only staged bundles without release provenance", () => {
+		const m = baseManifest("2b");
+		m.version = "1.0.0-weights-staged.2";
+		m.defaultEligible = false;
+		m.evals.asrWer = { wer: 1.4444, passed: false };
+		m.evals.expressive = {
+			tagFaithfulness: 0,
+			mosExpressive: 0,
+			tagLeakage: 1,
+			passed: false,
+		};
+		m.voice = {
+			version: "1",
+			frozen: true,
+			cache: {
+				speakerPreset: "cache/voice-preset-default.bin",
+				phraseCacheSeed: "cache/voice-preset-default.bin",
+			},
+			capabilities: ["tts", "emotion-tags", "singing"],
+		};
+
+		expect(validateManifest(m).ok).toBe(true);
+		expect(canSetAsDefault(m, device)).toBe(false);
+	});
+});
+
+describe("releaseChannel", () => {
+	it("accepts an absent releaseChannel (defaults to recommended)", () => {
+		const result = validateManifest(baseManifest("9b"));
+		expect(result.ok).toBe(true);
+	});
+
+	it("accepts releaseChannel=recommended", () => {
+		const m = { ...baseManifest("9b"), releaseChannel: "recommended" as const };
+		expect(validateManifest(m).ok).toBe(true);
+	});
+
+	it("accepts releaseChannel=base-v1 only when defaultEligible is false", () => {
+		const m = {
+			...baseManifest("9b"),
+			releaseChannel: "base-v1" as const,
+			defaultEligible: false,
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(true);
+	});
+
+	it("rejects releaseChannel=base-v1 with defaultEligible=true", () => {
+		const m = {
+			...baseManifest("9b"),
+			releaseChannel: "base-v1" as const,
+			defaultEligible: true,
+		};
+		const result = validateManifest(m);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.errors.some((e) => e.includes("base-v1"))).toBe(true);
+		}
+	});
+
+	it("rejects an unknown releaseChannel value", () => {
+		const m = { ...baseManifest("9b"), releaseChannel: "v3" as never };
+		expect(validateManifest(m).ok).toBe(false);
+	});
+
+	it("a contract-valid base-v1-channel manifest is allowed as a device default", () => {
+		// The publish-side claim ("this is the base, not the strict release")
+		// is encoded by releaseChannel + defaultEligible:false. The on-device
+		// gate is a separate question: if the bundle is contract-valid and the
+		// device can run it, it is allowed to fill an empty default slot. The
+		// recommender prefers a strict-release bundle when both are installed.
+		const m = {
+			...baseManifest("9b"),
+			releaseChannel: "base-v1" as const,
+			defaultEligible: false,
+		};
+		expect(
+			canSetAsDefault(m, { availableBackends: ["metal"], ramMb: 64_000 }),
+		).toBe(true);
+	});
+});