@elizaos/plugin-local-inference 2.0.3-beta.2 → 2.0.3-beta.4

package/src/services/active-model.ts

@@ -22,15 +22,28 @@ import {
 	FIRST_RUN_DEFAULT_MODEL_ID,
 	findCatalogModel,
 } from "./catalog";
+import {
+	computeRuntimeContextFit,
+	type RuntimeContextFit,
+} from "./context-fit";
 import { localInferenceEngine } from "./engine";
 import { probeHardware } from "./hardware";
-import type { Eliza1Manifest } from "./manifest";
+import {
+	type Eliza1Kernel,
+	type Eliza1Manifest,
+	type Eliza1Tier,
+	missingRequiredKernels,
+	OPTIONAL_KERNELS_BY_TIER,
+	REQUIRED_KERNELS_BY_TIER,
+	RUNTIME_TO_ELIZA1_KERNEL,
+} from "./manifest";
 import {
 	assessRamFit,
 	defaultManifestLoader,
 	type ManifestLoader,
 	pickFittingContextVariant,
 	type RamFitOptions,
+	ramHeadroomReserveMb,
 } from "./ram-budget";
 import { recommendForFirstRun } from "./recommendation";
 import { touchElizaModel } from "./registry";
@@ -262,6 +275,7 @@ export interface LocalInferenceLoadOverrides {
 
 interface ResolveLocalInferenceLoadArgsOptions {
 	manifestLoader?: ManifestLoader;
+	hardware?: HardwareProbe;
 }
 
 function bundleRootForInstalledModel(installed: InstalledModel): string {
@@ -368,6 +382,7 @@ function applyCatalogDefaults(
 	installed: InstalledModel,
 	catalog: CatalogModel | undefined,
 	manifestLoader: ManifestLoader,
+	hardware: HardwareProbe | undefined,
 ): void {
 	const runtime = catalog?.runtime;
 
@@ -382,9 +397,28 @@ function applyCatalogDefaults(
 	// happens to use ("auto" → smallest fitting, which historically meant
 	// 4k or 8k even for 128k-trained models).
 	if (args.contextSize === undefined) {
-		args.contextSize =
+		const nativeContext =
 			installedBundleContextSize(installed, manifestLoader) ??
 			catalog?.contextLength;
+		const fit = resolveRuntimeContextFit(
+			installed,
+			catalog,
+			nativeContext,
+			hardware,
+		);
+		args.contextSize = fit?.contextSize ?? nativeContext;
+		// Headroom KV-precision upgrade: when the selector chose f16 (opt-in via
+		// ELIZA_PREFER_ACCURATE_KV_WHEN_HEADROOM) and the caller/catalog left KV at
+		// the default q8_0, raise both cache types to f16. Only ever upgrades, and
+		// only when f16 still affords the selected window (#8809 AC#4).
+		if (
+			fit?.kvQuant === "f16" &&
+			(args.cacheTypeK === undefined || args.cacheTypeK === "q8_0") &&
+			(args.cacheTypeV === undefined || args.cacheTypeV === "q8_0")
+		) {
+			args.cacheTypeK = "f16";
+			args.cacheTypeV = "f16";
+		}
 	}
 
 	// Catalog-declared GPU offload default — only apply when the caller
@@ -418,6 +452,56 @@ function applyCatalogDefaults(
 	}
 }
 
+function installedWeightMb(
+	installed: InstalledModel,
+	catalog: CatalogModel | undefined,
+): number {
+	if (
+		typeof installed.sizeBytes === "number" &&
+		Number.isFinite(installed.sizeBytes) &&
+		installed.sizeBytes > 0
+	) {
+		return installed.sizeBytes / (1024 * 1024);
+	}
+	if (
+		catalog &&
+		typeof catalog.sizeGb === "number" &&
+		Number.isFinite(catalog.sizeGb) &&
+		catalog.sizeGb > 0
+	) {
+		return catalog.sizeGb * 1024;
+	}
+	return 0;
+}
+
+/** ELIZA_PREFER_ACCURATE_KV_WHEN_HEADROOM=1 opts into the f16-KV-on-headroom path. */
+function preferAccurateKvWhenHeadroom(): boolean {
+	const v =
+		process.env.ELIZA_PREFER_ACCURATE_KV_WHEN_HEADROOM?.trim().toLowerCase();
+	return v === "1" || v === "true" || v === "yes";
+}
+
+function resolveRuntimeContextFit(
+	installed: InstalledModel,
+	catalog: CatalogModel | undefined,
+	nativeContext: number | undefined,
+	hardware: HardwareProbe | undefined,
+): RuntimeContextFit | null {
+	if (!catalog || nativeContext === undefined) return null;
+	if (!hardware) return null;
+
+	return computeRuntimeContextFit({
+		params: catalog.params,
+		weightMb: installedWeightMb(installed, catalog),
+		usableMb: Math.max(
+			0,
+			hostRamMbFromProbe(hardware) - ramHeadroomReserveMb(),
+		),
+		nativeContext,
+		preferAccurateKvWhenHeadroom: preferAccurateKvWhenHeadroom(),
+	});
+}
+
 function mergeOverrides(
 	args: LocalInferenceLoadArgs,
 	overrides: LocalInferenceLoadOverrides | undefined,
@@ -557,7 +641,13 @@ export async function resolveLocalInferenceLoadArgs(
 	const runtime = catalog?.runtime;
 	const manifestLoader = options.manifestLoader ?? defaultManifestLoader;
 
-	applyCatalogDefaults(args, installed, catalog, manifestLoader);
+	applyCatalogDefaults(
+		args,
+		installed,
+		catalog,
+		manifestLoader,
+		options.hardware,
+	);
 
 	// WS2: when the tier declares vision and the per-tier mmproj GGUF is
 	// already on disk, plumb the path. The text load is never gated on
@@ -574,10 +664,10 @@ export async function resolveLocalInferenceLoadArgs(
 		// here; `applyCatalogDefaults` owns the chat-side context. The MTP
 		// block only owns the speculative draft window.
 		//
-		// Two MTP shapes: same-file MTP embeds the NextN head in the text
-		// GGUF (no `drafterFile` in the catalog) and runs with no separate
-		// draft model; separate-drafter MTP declares a `drafterFile` and
-		// requires the bundled drafter GGUF to be present on disk.
+		// Two MTP shapes: embedded-draft-head MTP embeds the draft head in
+		// the text GGUF (no `drafterFile` in the catalog) and runs with no
+		// separate draft model; separate-drafter MTP declares a `drafterFile`
+		// and requires the bundled drafter GGUF to be present on disk.
 		const sameFileMtp = !mtp.drafterFile;
 		const drafterPath = sameFileMtp
 			? undefined
@@ -895,6 +985,102 @@ function collectFailedEvalNames(manifest: Eliza1Manifest): string[] {
 	return failed;
 }
 
+/**
+ * Refusal raised when activation is asked for a manifest-shipping bundle whose
+ * declared `kernels.required` is missing one of the kernels its tier requires
+ * (`REQUIRED_KERNELS_BY_TIER`). native/CLAUDE.md §3#5 makes this a hard error:
+ * a bundle that doesn't declare its required quant/attention kernels would emit
+ * garbage (or silently fall back to an un-optimized path), so we refuse to
+ * activate it rather than run a broken model.
+ */
+export class MissingRequiredKernelsError extends Error {
+	readonly modelId: string;
+	readonly tier: Eliza1Tier;
+	readonly missing: ReadonlyArray<Eliza1Kernel>;
+
+	constructor(args: {
+		modelId: string;
+		tier: Eliza1Tier;
+		missing: ReadonlyArray<Eliza1Kernel>;
+	}) {
+		super(
+			`Model "${args.modelId}" (tier ${args.tier}) is missing required kernel(s): ${args.missing.join(", ")}. Its manifest declares kernels.required without the tier's mandatory set (${REQUIRED_KERNELS_BY_TIER[args.tier].join(", ")}). Refusing to activate — re-fetch a correctly-built bundle.`,
+		);
+		this.name = "MissingRequiredKernelsError";
+		this.modelId = args.modelId;
+		this.tier = args.tier;
+		this.missing = args.missing;
+	}
+}
+
+/**
+ * Activation kernel gate (native/CLAUDE.md §3#5). When the installed bundle
+ * ships a manifest, verify it declares every kernel its tier requires; throw
+ * `MissingRequiredKernelsError` otherwise. A bundle with no manifest (bare
+ * GGUF, external scan, dev path) is NOT gated — there is no kernel contract to
+ * check, so it is a no-op.
+ */
+export function assertRequiredKernelsPresent(
+	installed: InstalledModel,
+	manifestLoader: ManifestLoader = defaultManifestLoader,
+): void {
+	const manifest = manifestLoader(installed.id, installed);
+	if (!manifest) return;
+	const missing = missingRequiredKernels(
+		manifest.tier,
+		manifest.kernels.required,
+	);
+	if (missing.length === 0) return;
+	throw new MissingRequiredKernelsError({
+		modelId: installed.id,
+		tier: manifest.tier,
+		missing,
+	});
+}
+
+/**
+ * native/CLAUDE.md §3#5: "The runtime MUST log the kernel set on startup."
+ * Emits one structured line per activation naming the resolved required +
+ * optional kernel set and the compute backend. Required is the union of the
+ * tier's mandatory manifest kernels and any catalog-declared `requiresKernel`
+ * (mapped runtime→manifest); optional is the tier's optional set. Best-effort:
+ * never throws — a bad probe or unknown tier degrades the line, never the load.
+ */
+function logResolvedKernelSet(
+	installed: InstalledModel,
+	catalog: CatalogModel | undefined,
+	manifest: Eliza1Manifest | undefined,
+	probe: HardwareProbe,
+): void {
+	const tier: Eliza1Tier | undefined =
+		manifest?.tier ??
+		(installed.id.startsWith("eliza-1-")
+			? (installed.id.slice("eliza-1-".length) as Eliza1Tier)
+			: undefined);
+	if (!tier || !REQUIRED_KERNELS_BY_TIER[tier]) return;
+
+	const required = new Set<Eliza1Kernel>(REQUIRED_KERNELS_BY_TIER[tier]);
+	for (const runtimeKernel of catalog?.runtime?.optimizations?.requiresKernel ??
+		[]) {
+		const mapped = RUNTIME_TO_ELIZA1_KERNEL[runtimeKernel as never];
+		if (mapped) required.add(mapped);
+	}
+	const optional = OPTIONAL_KERNELS_BY_TIER[tier];
+	const backend = resolveComputeBackendLabel(probe);
+	console.info(
+		`[LocalInferenceEngine] kernel set: required=[${[...required].join(", ")}] optional=[${optional.join(", ")}] backend=${backend}`,
+	);
+}
+
+/**
+ * Best-effort label for the compute backend the fused lib will autoselect.
+ * The actual CPU/GPU pick happens inside the FFI runtime; this reports the
+ * host probe's detected GPU backend (or `cpu`) for the startup log only.
+ */
+function resolveComputeBackendLabel(probe: HardwareProbe): string {
+	return probe.gpu ? probe.gpu.backend : "cpu";
+}
+
 function isLoader(value: unknown): value is LocalInferenceLoader {
 	if (!value || typeof value !== "object") return false;
 	const candidate = value as Partial<LocalInferenceLoader>;
@@ -1002,6 +1188,12 @@ export class ActiveModelCoordinator {
 		// it sees the 422 from the route layer directly.
 		assertManifestEvalsPassed(installed, opts.manifestLoader);
 
+		// Activation kernel gate (native/CLAUDE.md §3#5). A manifest-shipping
+		// bundle that doesn't declare its tier's required kernels would run an
+		// un-optimized/broken path — refuse it here, before the loading state,
+		// same as the eval gate. No-op for bare-GGUF/dev bundles (no manifest).
+		assertRequiredKernelsPresent(installed, opts.manifestLoader);
+
 		this.state = {
 			modelId: installed.id,
 			loadedAt: null,
@@ -1131,7 +1323,9 @@ export class ActiveModelCoordinator {
 				`[local-inference] Loading "${installed.id}" with tight RAM headroom (~${admission.minMb} MB floor, ${admission.recommendedMb} MB recommended; ${hostRamMbFromProbe(probe)} MB host). Expect swapping under sustained load.`,
 			);
 		}
-		const resolved = await resolveLocalInferenceLoadArgs(installed, overrides);
+		const resolved = await resolveLocalInferenceLoadArgs(installed, overrides, {
+			hardware: probe,
+		});
 		// WS2: warn one-shot when the tier declares vision but the
 		// per-tier mmproj GGUF isn't on disk yet. The text load still
 		// proceeds; vision capability is degraded for this session
@@ -1144,6 +1338,15 @@ export class ActiveModelCoordinator {
 		} else {
 			await localInferenceEngine.load(installed.path, resolved);
 		}
+		// native/CLAUDE.md §3#5: log the resolved kernel set once per activation,
+		// after the load lands. Best-effort — never throws.
+		const manifestLoader = opts.manifestLoader ?? defaultManifestLoader;
+		logResolvedKernelSet(
+			installed,
+			findCatalogModel(installed.id),
+			manifestLoader(installed.id, installed) ?? undefined,
+			probe,
+		);
 		const runtimeLoad = loader
 			? null
 			: localInferenceEngine.currentRuntimeLoadConfig();

package/src/services/asr-provenance.ts

@@ -0,0 +1,68 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+export const QWEN_PROVENANCE_RE = /\bqwen/i;
+
+function readStringPath(
+	input: unknown,
+	keys: readonly string[],
+): string | undefined {
+	let current: unknown = input;
+	for (const key of keys) {
+		if (!current || typeof current !== "object") return undefined;
+		current = (current as Record<string, unknown>)[key];
+	}
+	return typeof current === "string" ? current : undefined;
+}
+
+export function collectQwenAsrProvenanceBlockers(input: unknown): string[] {
+	const blockers: string[] = [];
+	const asrBase = readStringPath(input, ["lineage", "asr", "base"]);
+	if (asrBase && QWEN_PROVENANCE_RE.test(asrBase)) {
+		blockers.push(
+			`lineage.asr.base: a strict/defaultEligible Gemma-4 release must not ship Qwen ASR provenance (${asrBase})`,
+		);
+	}
+	const asrRepo = readStringPath(input, [
+		"provenance",
+		"sourceModels",
+		"asr",
+		"repo",
+	]);
+	if (asrRepo && QWEN_PROVENANCE_RE.test(asrRepo)) {
+		blockers.push(
+			`provenance.sourceModels.asr.repo: a strict/defaultEligible Gemma-4 release must not source ASR from Qwen (${asrRepo})`,
+		);
+	}
+	return blockers;
+}
+
+export function readBundleAsrProvenanceBlockers(bundleRoot: string): string[] {
+	const manifestPath = path.join(bundleRoot, "eliza-1.manifest.json");
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+	} catch {
+		return [];
+	}
+	return collectQwenAsrProvenanceBlockers(parsed);
+}
+
+function directoryHasRegularFile(dir: string): boolean {
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const child = path.join(dir, entry.name);
+		if (entry.isFile()) return true;
+		if (entry.isDirectory() && directoryHasRegularFile(child)) return true;
+	}
+	return false;
+}
+
+export function bundleHasAsrModelFiles(bundleRoot: string): boolean {
+	const asrDir = path.join(bundleRoot, "asr");
+	if (!existsSync(asrDir)) return false;
+	try {
+		return directoryHasRegularFile(asrDir);
+	} catch {
+		return false;
+	}
+}

package/src/services/assignment-validation.test.ts

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+	AssignmentRejectedError,
+	readAssignments,
+	setAssignment,
+} from "./assignments";
+import { elizaModelsDir } from "./paths";
+import { upsertElizaModel } from "./registry";
+import type { InstalledModel } from "./types";
+
+const originalEnv = { ...process.env };
+
+beforeEach(() => {
+	process.env.ELIZA_STATE_DIR = fs.mkdtempSync(
+		path.join(os.tmpdir(), "eliza-assignment-validate-"),
+	);
+	// Default to a desktop host (no explicit-modelPath generic binding).
+	delete process.env.ELIZA_PLATFORM;
+});
+
+afterEach(() => {
+	const dir = process.env.ELIZA_STATE_DIR;
+	process.env = { ...originalEnv };
+	if (dir?.includes("eliza-assignment-validate-")) {
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+async function registerForeignModel(): Promise<InstalledModel> {
+	// A model whose id is NOT a curated Eliza-1 tier. The setAssignment boundary
+	// must reject it — the local stack is Eliza-1 only (#8808).
+	const dir = elizaModelsDir();
+	fs.mkdirSync(dir, { recursive: true });
+	const filePath = path.join(dir, "llama-3.2-3b-q4.gguf");
+	fs.writeFileSync(filePath, "gguf");
+	const model: InstalledModel = {
+		id: "hf:meta-llama/Llama-3.2-3B-Instruct-GGUF::Llama-3.2-3B-Instruct-Q4_K_M.gguf",
+		displayName: "Llama-3.2-3B-Instruct",
+		path: filePath,
+		sizeBytes: 4,
+		installedAt: new Date().toISOString(),
+		lastUsedAt: null,
+		source: "eliza-download",
+	};
+	await upsertElizaModel(model);
+	return model;
+}
+
+async function registerFusedModel(): Promise<InstalledModel> {
+	const bundleRoot = path.join(elizaModelsDir(), "eliza-1-4b");
+	const textDir = path.join(bundleRoot, "text");
+	fs.mkdirSync(textDir, { recursive: true });
+	const filePath = path.join(textDir, "eliza-1-4b-128k.gguf");
+	fs.writeFileSync(filePath, "gguf");
+	const model: InstalledModel = {
+		id: "eliza-1-4b",
+		displayName: "eliza-1-4b",
+		path: filePath,
+		sizeBytes: 4,
+		bundleRoot,
+		installedAt: new Date().toISOString(),
+		lastUsedAt: null,
+		source: "eliza-download",
+		runtimeClass: "fused-eliza1",
+	};
+	await upsertElizaModel(model);
+	return model;
+}
+
+// (Removed "canServeRuntimeClassOnHost" suite — the generic-gguf runtime
+// class + its host-servability helper were retired in the eliza-1-only
+// cutover (#8808/#9033). The setAssignment boundary tests below now own the
+// "non-eliza-1 models are rejected" contract.)
+
+describe("setAssignment boundary validation", () => {
+	it("rejects a non-Eliza-1 model on desktop before assignment writes", async () => {
+		const model = await registerForeignModel();
+		await expect(setAssignment("TEXT_LARGE", model.id)).rejects.toBeInstanceOf(
+			AssignmentRejectedError,
+		);
+		// Nothing was written.
+		expect(await readAssignments()).toEqual({});
+	});
+
+	it("rejects a non-Eliza-1 model on mobile too", async () => {
+		process.env.ELIZA_PLATFORM = "ios";
+		const model = await registerForeignModel();
+		await expect(setAssignment("TEXT_LARGE", model.id)).rejects.toThrow(
+			/curated Eliza-1/i,
+		);
+		expect(await readAssignments()).toEqual({});
+	});
+
+	it("always accepts a fused Eliza-1 model on desktop", async () => {
+		const model = await registerFusedModel();
+		const next = await setAssignment("TEXT_LARGE", model.id);
+		expect(next.TEXT_LARGE).toBe(model.id);
+	});
+
+	it("allows a not-yet-installed catalog id through (policy, not load)", async () => {
+		// An id that is not in the registry is a declared policy; the readiness
+		// layer surfaces the missing file separately — validation must not block.
+		const next = await setAssignment("TEXT_SMALL", "eliza-1-9b");
+		expect(next.TEXT_SMALL).toBe("eliza-1-9b");
+	});
+
+	it("clearing a slot is never gated", async () => {
+		const model = await registerFusedModel();
+		await setAssignment("TEXT_LARGE", model.id);
+		delete process.env.ELIZA_PLATFORM; // back to desktop
+		const next = await setAssignment("TEXT_LARGE", null);
+		expect(next.TEXT_LARGE).toBeUndefined();
+	});
+});

package/src/services/assignments.test.ts

@@ -6,6 +6,8 @@ import {
 	buildRecommendedAssignments,
 	ensureDefaultAssignment,
 	readAssignments,
+	setAssignment,
+	writeAssignments,
 } from "./assignments";
 import type { InstalledModel } from "./types";
 
@@ -77,4 +79,28 @@ describe("local inference assignments", () => {
 
 		expect(await readAssignments()).toEqual({});
 	});
+
+	it("rejects custom assignment writes", async () => {
+		process.env.ELIZA_STATE_DIR = fs.mkdtempSync(
+			path.join(os.tmpdir(), "eliza-assignments-test-"),
+		);
+
+		await expect(
+			setAssignment("TEXT_LARGE", "hf:some-org/some-model::model.Q4_K_M.gguf"),
+		).rejects.toThrow(/curated Eliza-1/i);
+		expect(await readAssignments()).toEqual({});
+	});
+
+	it("drops stale custom ids while preserving curated assignments", async () => {
+		process.env.ELIZA_STATE_DIR = fs.mkdtempSync(
+			path.join(os.tmpdir(), "eliza-assignments-test-"),
+		);
+
+		await writeAssignments({
+			TEXT_SMALL: "eliza-1-4b",
+			TEXT_LARGE: "hf:some-org/some-model::model.Q4_K_M.gguf",
+		});
+
+		expect(await readAssignments()).toEqual({ TEXT_SMALL: "eliza-1-4b" });
+	});
 });

package/src/services/assignments.ts

@@ -20,6 +20,26 @@ import type { AgentModelSlot, InstalledModel, ModelAssignments } from "./types";
 
 const ASSIGNMENTS_FILENAME = "assignments.json";
 
+/**
+ * Raised when a slot assignment is outside the curated Eliza-1 catalog. The
+ * local stack is Eliza-1 only, so the assignment policy rejects anything else.
+ */
+export class AssignmentRejectedError extends Error {
+	readonly code = "ASSIGNMENT_REJECTED" as const;
+	readonly slot: AgentModelSlot;
+	readonly modelId: string;
+	constructor(args: {
+		slot: AgentModelSlot;
+		modelId: string;
+		message: string;
+	}) {
+		super(args.message);
+		this.name = "AssignmentRejectedError";
+		this.slot = args.slot;
+		this.modelId = args.modelId;
+	}
+}
+
 interface AssignmentsFile {
 	version: 1;
 	assignments: ModelAssignments;
@@ -29,6 +49,27 @@ function assignmentsPath(): string {
 	return path.join(localInferenceRoot(), ASSIGNMENTS_FILENAME);
 }
 
+function isCuratedEliza1AssignmentId(modelId: string): boolean {
+	const catalog = findCatalogModel(modelId);
+	return (
+		!!catalog &&
+		!catalog.hiddenFromCatalog &&
+		catalog.runtimeRole !== "mtp-drafter" &&
+		isDefaultEligibleId(catalog.id)
+	);
+}
+
+function sanitizeAssignments(assignments: ModelAssignments): ModelAssignments {
+	const next: ModelAssignments = {};
+	for (const [slot, modelId] of Object.entries(assignments) as Array<
+		[AgentModelSlot, string | undefined]
+	>) {
+		if (!modelId || !isCuratedEliza1AssignmentId(modelId)) continue;
+		next[slot] = modelId;
+	}
+	return next;
+}
+
 async function ensureRoot(): Promise<void> {
 	await fs.mkdir(localInferenceRoot(), { recursive: true });
 }
@@ -38,7 +79,7 @@ export async function readAssignments(): Promise<ModelAssignments> {
 		const raw = await fs.readFile(assignmentsPath(), "utf8");
 		const parsed = JSON.parse(raw) as AssignmentsFile;
 		if (parsed?.version !== 1 || !parsed.assignments) return {};
-		return parsed.assignments;
+		return sanitizeAssignments(parsed.assignments);
 	} catch {
 		return {};
 	}
@@ -58,9 +99,8 @@ function pickLargestInstalledModel(
  * Build slot recommendations from currently-installed models.
  *
  * Only default-eligible Eliza-1 downloads are auto-recommended.
- * External-scan blobs and ad-hoc Hugging Face downloads are surfaced only
- * through explicit search/manual selection; they are NOT auto-assigned to
- * any agent slot.
+ * External-scan blobs and ad-hoc Hugging Face downloads are never assigned to
+ * agent slots.
  *
  * Why: external blobs may use newer architectures or quant formats outside
  * the bundled `capacitor-llama` binding's supported set. Auto-loading
@@ -119,6 +159,14 @@ export async function setAssignment(
 	const current = await readAssignments();
 	const next: ModelAssignments = { ...current };
 	if (modelId) {
+		if (!isCuratedEliza1AssignmentId(modelId)) {
+			throw new AssignmentRejectedError({
+				slot,
+				modelId,
+				message:
+					"Local inference assignments are limited to curated Eliza-1 tiers.",
+			});
+		}
 		next[slot] = modelId;
 	} else {
 		delete next[slot];