@otto-code/brain 0.8.6 → 0.8.8

package/dist/cli.js

@@ -15,7 +15,7 @@ import { addRestartOptions, addServeOptions, addStartOptions, addStatusOptions,
 import { addPullOptions, runPullCommand } from "./commands/pull.js";
 import { addReportOptions, runReportCommand } from "./commands/report.js";
 import { addRescoreOptions, runRescoreCommand } from "./commands/rescore.js";
-import { addRuntimeInstallOptions, addRuntimeListOptions, runRuntimeInstallCommand, runRuntimeListCommand, } from "./commands/runtime.js";
+import { addRuntimeInstallOptions, addRuntimeListOptions, addRuntimeRemoveOptions, runRuntimeInstallCommand, runRuntimeListCommand, runRuntimeRemoveCommand, } from "./commands/runtime.js";
 import { addScanOptions, runScanCommand } from "./commands/scan.js";
 import { addAddOptions, addSearchOptions, runAddCommand, runSearchCommand, } from "./commands/search.js";
 import { addSweepOptions, runSweepCommand } from "./commands/sweep.js";
@@ -57,6 +57,7 @@ export function registerBrainCommands(program) {
     const runtime = program.command("runtime").description("Manage the llama.cpp runtime");
     addRuntimeListOptions(runtime.command("list")).action(withOutput(runRuntimeListCommand));
     addRuntimeInstallOptions(runtime.command("install")).action(withOutput(runRuntimeInstallCommand));
+    addRuntimeRemoveOptions(runtime.command("remove")).action(withOutput(runRuntimeRemoveCommand));
     // config subgroup.
     const config = program.command("config").description("Inspect and edit brain config");
     addConfigShowOptions(config.command("show")).action(withOutput(runConfigShowCommand));

package/dist/commands/catalog.d.ts

@@ -8,6 +8,7 @@
  * params, tier, use-cases) that only the JSON output surfaces.
  */
 import type { Command } from "commander";
+import type { CatalogModel } from "../config/schema.js";
 import type { AnyCommandResult, OutputSchema } from "../output/index.js";
 export interface CatalogRow {
     id: string;
@@ -25,6 +26,7 @@ export interface CatalogRow {
     tier: string;
     useCases: string[];
     why: string;
+    components?: CatalogModel["components"];
 }
 export declare const catalogSchema: OutputSchema<CatalogRow>;
 export declare function addCatalogOptions(cmd: Command): Command;

package/dist/commands/catalog.js

@@ -42,6 +42,7 @@ export async function runCatalogCommand(_options, _command) {
         tier: model.tier ?? "",
         useCases: model.useCases ?? [],
         why: model.why ?? "",
+        components: model.components,
     }));
     return { type: "list", data: rows, schema: catalogSchema };
 }

package/dist/commands/pull.d.ts

@@ -17,6 +17,7 @@ export interface PullOptionsInput {
     file?: string;
     quant?: string;
     listQuants?: boolean;
+    component?: string[];
 }
 export declare function runPullCommand(modelArg: string, options: PullOptionsInput, _command: Command): Promise<AnyCommandResult<PullRow>>;
 //# sourceMappingURL=pull.d.ts.map

package/dist/commands/pull.js

@@ -1,5 +1,5 @@
 import { loadBrainConfig, loadCatalog } from "../config/index.js";
-import { downloadRepoFiles, listRepoQuants, managedModelsDir, pullModel, resolveHfToken, } from "../models/index.js";
+import { downloadRepoFiles, bundleDownloadPlan, listRepoQuants, managedModelsDir, pullModel, resolveHfToken, } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { formatBytes } from "../models/scan.js";
 import { withActivity } from "../service/activity.js";
@@ -44,6 +44,7 @@ export function addPullOptions(cmd) {
         .argument("<model>", "catalog id or name fragment")
         .option("--file <name.gguf>", "explicit GGUF file name in the repo")
         .option("--quant <label>", "download a specific quantization (e.g. Q5_K_M)")
+        .option("--component <id...>", "download optional bundle component ids")
         .option("--list-quants", "list the quantizations the repo offers and exit");
 }
 export async function runPullCommand(modelArg, options, _command) {
@@ -51,6 +52,56 @@ export async function runPullCommand(modelArg, options, _command) {
     const catalog = loadCatalog();
     const model = findCatalogModel(catalog.models, modelArg);
     const token = resolveHfToken(config);
+    // A bundle combines one selected primary quant and explicit optional
+    // companions. It must not pull the generic discovery projector as a side
+    // effect, because that makes the download plan ambiguous.
+    if (model.components && !options.listQuants && !options.file) {
+        const { quants } = await listRepoQuants(model.hfRepo, token);
+        const choice = options.quant
+            ? quants.find((quant) => quant.quant.toLowerCase() === options.quant.toLowerCase())
+            : undefined;
+        if (options.quant && !choice) {
+            throw new CommandError({
+                code: "NO_QUANT",
+                message: `${model.hfRepo} has no ${options.quant}`,
+            });
+        }
+        const plan = bundleDownloadPlan(model, options.component ?? [], choice?.files, choice?.sizeBytes);
+        let lastPct = -1;
+        const written = await withActivity("download", { target: model.name }, (activity) => downloadRepoFiles({
+            repo: plan.repo,
+            files: plan.files,
+            destRoot: managedModelsDir(config),
+            token,
+            onProgress: (progress) => {
+                activity.update(plan.totalBytes ? progress.receivedBytes / plan.totalBytes : null);
+                // The daemon owns the UI job record and only sees this child's
+                // stdout/stderr. Activity also feeds the host status, but emitting
+                // here is what keeps the Library's bundle progress ring live.
+                const pct = plan.totalBytes
+                    ? Math.floor((progress.receivedBytes / plan.totalBytes) * 100)
+                    : 0;
+                // Network chunks do not land exactly on 5% boundaries. Emit every
+                // new integer so the daemon receives continuous progress instead of
+                // often seeing only the initial and final updates.
+                if (pct > lastPct) {
+                    lastPct = pct;
+                    process.stderr.write(`  ${model.name}${choice ? ` ${choice.quant}` : ""}: ${pct}%\r`);
+                }
+            },
+        }));
+        process.stderr.write("\n");
+        return {
+            type: "single",
+            data: {
+                model: choice ? `${model.name} (${choice.quant})` : model.name,
+                repo: model.hfRepo,
+                path: written[0] ?? "(already present)",
+                size: plan.totalBytes ? formatBytes(plan.totalBytes) : "-",
+            },
+            schema: pullSchema,
+        };
+    }
     // Discover-and-choose paths both need the repo's quant listing.
     if (options.listQuants || options.quant) {
         const { quants, mmproj } = await listRepoQuants(model.hfRepo, token);
@@ -61,6 +112,7 @@ export async function runPullCommand(modelArg, options, _command) {
                     quant: q.quant,
                     size: formatBytes(q.sizeBytes),
                     files: q.files.length,
+                    fileNames: q.files,
                 })),
                 schema: quantSchema,
             };
@@ -87,7 +139,7 @@ export async function runPullCommand(modelArg, options, _command) {
             onProgress: (p) => {
                 activity.update(total ? p.receivedBytes / total : null);
                 const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
-                if (pct !== lastPct && pct % 5 === 0) {
+                if (pct > lastPct) {
                     lastPct = pct;
                     process.stderr.write(`  ${model.name} ${choice.quant}: ${pct}%\r`);
                 }
@@ -119,7 +171,7 @@ export async function runPullCommand(modelArg, options, _command) {
                 return;
             activity.update(p.receivedBytes / p.totalBytes);
             const pct = Math.floor((p.receivedBytes / p.totalBytes) * 100);
-            if (pct !== lastPct && pct % 5 === 0) {
+            if (pct > lastPct) {
                 lastPct = pct;
                 process.stderr.write(`  ${model.name}: ${pct}%\r`);
             }

package/dist/commands/runtime.d.ts

@@ -8,6 +8,7 @@ import type { Command } from "commander";
 import type { AnyCommandResult } from "../output/index.js";
 export interface RuntimeRow {
     label: string;
+    displayName: string;
     version: string;
     source: string;
     dir: string;
@@ -15,6 +16,8 @@ export interface RuntimeRow {
 export declare function addRuntimeListOptions(cmd: Command): Command;
 export declare function runRuntimeListCommand(_options: unknown, _command: Command): Promise<AnyCommandResult<RuntimeRow>>;
 export declare function addRuntimeInstallOptions(cmd: Command): Command;
+export declare function addRuntimeRemoveOptions(cmd: Command): Command;
+export declare function runRuntimeRemoveCommand(name: string, _options: unknown, _command: Command): Promise<AnyCommandResult<RuntimeRow>>;
 export declare function runRuntimeInstallCommand(options: {
     build?: string;
     variant?: string;

package/dist/commands/runtime.js

@@ -1,7 +1,7 @@
 import { loadBrainConfig } from "../config/index.js";
 import { resolveBrainPaths } from "../config/paths.js";
 import { CommandError } from "../output/types.js";
-import { defaultRuntimeSpec, installManagedRuntime, listAllRuntimes, listRuntimeDevices, probeNvidiaGpu, supportedVariants, } from "../runtime/index.js";
+import { DEFAULT_LLAMA_BUILD, defaultRuntimeSpec, installManagedRuntime, MissingAssetError, removeManagedRuntime, resolveLatestBuildOrPin, listAllRuntimes, listRuntimeDevices, probeNvidiaGpu, supportedVariants, } from "../runtime/index.js";
 const runtimeSchema = {
     idField: "dir",
     columns: [
@@ -19,6 +19,7 @@ const runtimeSchema = {
 function toRows() {
     return listAllRuntimes().map((r) => ({
         label: r.label,
+        displayName: r.displayName ?? `${r.label} · ${r.version}`,
         version: r.version,
         source: r.source,
         dir: r.dir,
@@ -33,9 +34,40 @@ export async function runRuntimeListCommand(_options, _command) {
 export function addRuntimeInstallOptions(cmd) {
     return cmd
         .description("Download a self-contained llama.cpp runtime")
-        .option("--build <tag>", "llama.cpp release build tag")
+        .option("--build <tag>", "llama.cpp release build tag (for example b10355)")
         .option("--variant <name>", `accelerator to install (${supportedVariants().join("|")}); defaults to the best one this machine can use`);
 }
+export function addRuntimeRemoveOptions(cmd) {
+    return cmd.description("Remove one Otto-managed runtime").argument("<name>");
+}
+export async function runRuntimeRemoveCommand(name, _options, _command) {
+    loadBrainConfig();
+    removeManagedRuntime(resolveBrainPaths().runtimesDir, name);
+    return { type: "list", data: toRows(), schema: runtimeSchema };
+}
+/**
+ * Every warning this command emits is one line on purpose. The daemon's
+ * BrainOpsManager keeps the *last* stderr line as the job's message, so a
+ * multi-line warning would surface in the UI as a dangling fragment. As one line
+ * it survives intact on both the CLI and the GUI.
+ */
+function warn(message) {
+    process.stderr.write(`  warning: ${message.replace(/\s+/gu, " ").trim()}\n`);
+}
+/** Download + extract a spec, reporting percentage and phase on stderr. */
+async function install(spec, runtimesDir) {
+    process.stderr.write(`  installing ${spec.label} (${spec.version})…\n`);
+    const runtime = await installManagedRuntime(spec, runtimesDir, (p) => {
+        if (p.phase === "downloading" && p.totalBytes) {
+            const pct = Math.floor(((p.receivedBytes ?? 0) / p.totalBytes) * 100);
+            process.stderr.write(`  ${pct}%\r`);
+        }
+        if (p.phase === "extracting")
+            process.stderr.write("\n  extracting…\n");
+    });
+    process.stderr.write("\n");
+    return runtime;
+}
 export async function runRuntimeInstallCommand(options, _command) {
     loadBrainConfig();
     const { runtimesDir } = resolveBrainPaths();
@@ -49,38 +81,53 @@ export async function runRuntimeInstallCommand(options, _command) {
     }
     // Only "auto" needs the GPU probe, and only to choose between CUDA and Vulkan
     // on the platforms that have both.
-    const spec = defaultRuntimeSpec(options.build, {
+    const target = {
         variant: options.variant ?? "auto",
         hasNvidiaGpu: options.variant ? undefined : await probeNvidiaGpu(),
-    });
-    process.stderr.write(`  installing ${spec.label} (${spec.version})…\n`);
-    const runtime = await installManagedRuntime(spec, runtimesDir, (p) => {
-        if (p.phase === "downloading" && p.totalBytes) {
-            const pct = Math.floor(((p.receivedBytes ?? 0) / p.totalBytes) * 100);
-            process.stderr.write(`  ${pct}%\r`);
+    };
+    // "latest" is a request to update, not a promise upstream can always keep: the
+    // lookup is unauthenticated and rate limited, so it falls back to the pin.
+    const resolvedLatest = options.build === "latest" ? await resolveLatestBuildOrPin() : null;
+    if (resolvedLatest?.warning)
+        warn(resolvedLatest.warning);
+    let spec = defaultRuntimeSpec(resolvedLatest ? resolvedLatest.build : options.build, target);
+    let runtime;
+    try {
+        runtime = await install(spec, runtimesDir);
+    }
+    catch (error) {
+        // Asset names are not derivable from the build tag, and the scheme has
+        // already changed once (b4600 shipped `win-cuda-cu12.4-x64`, b10265 ships
+        // `win-cuda-12.4-x64`), so a tag resolved at run time can name assets that
+        // do not exist under it. The pin's names are the ones managed.test.ts holds,
+        // which makes it the only build this can fall back to. An explicit --build
+        // still fails loudly: the user named that tag on purpose.
+        if (!(error instanceof MissingAssetError) ||
+            !resolvedLatest ||
+            spec.version === DEFAULT_LLAMA_BUILD) {
+            throw error;
         }
-        if (p.phase === "extracting")
-            process.stderr.write("\n  extracting…\n");
-    });
-    process.stderr.write("\n");
+        warn(`llama.cpp build ${spec.version} does not publish the asset this platform needs,` +
+            ` so Otto installed the pinned build ${DEFAULT_LLAMA_BUILD} instead.`);
+        spec = defaultRuntimeSpec(DEFAULT_LLAMA_BUILD, target);
+        runtime = await install(spec, runtimesDir);
+    }
     // A GPU variant that finds no device still runs - on the CPU, at roughly a
     // fortieth of the prefill throughput, and says nothing about it. Measured on
     // WSL2, which carries no NVIDIA Vulkan ICD. Warn rather than fail: the runtime
     // is genuinely installed and usable, just not accelerated.
-    // One line on purpose. The daemon's BrainOpsManager keeps the *last* stderr line
-    // as the job's message, so a multi-line warning would surface in the UI as a
-    // dangling fragment. As one line it survives intact on both the CLI and the GUI.
     if (spec.variant !== "cpu") {
         const devices = await listRuntimeDevices(runtime);
         if (devices.length === 0) {
-            process.stderr.write(`  warning: this ${spec.variant} runtime reports no GPU device, so inference will run` +
-                ` on the CPU until a working ${spec.variant} driver for this GPU is installed.\n`);
+            warn(`this ${spec.variant} runtime reports no GPU device, so inference will run` +
+                ` on the CPU until a working ${spec.variant} driver for this GPU is installed.`);
         }
     }
     return {
         type: "single",
         data: {
             label: runtime.label,
+            displayName: runtime.displayName ?? `${runtime.label} · ${runtime.version}`,
             version: runtime.version,
             source: runtime.source,
             dir: runtime.dir,

package/dist/commands/search.d.ts

@@ -12,6 +12,7 @@ export interface SearchRow {
     likes: number;
     gated: string;
     installed: boolean;
+    summary: string | null;
 }
 export declare function addSearchOptions(cmd: Command): Command;
 export declare function runSearchCommand(query: string, options: {
@@ -27,5 +28,7 @@ export declare function addAddOptions(cmd: Command): Command;
 export declare function runAddCommand(repo: string, options: {
     quant?: string;
     listQuants?: boolean;
+    component?: string[];
+    primaryOnly?: boolean;
 }, _command: Command): Promise<AnyCommandResult<AddRow>>;
 //# sourceMappingURL=search.d.ts.map

package/dist/commands/search.js

@@ -5,16 +5,19 @@ import { CommandError } from "../output/types.js";
 /** What is already on disk, so search + quant listings can mark installed rows. */
 function installedIndex(config) {
     const repos = new Set();
-    const quants = new Set();
+    const quants = new Map();
+    const projectorRepos = new Set();
     for (const model of scanModels(config)) {
         const repo = repoOfModel(model);
         if (!repo)
             continue;
         repos.add(repo.toLowerCase());
         if (model.quant)
-            quants.add(`${repo.toLowerCase()} ${model.quant.toUpperCase()}`);
+            quants.set(`${repo.toLowerCase()} ${model.quant.toUpperCase()}`, model.id);
+        if (model.mmprojPath)
+            projectorRepos.add(repo.toLowerCase());
     }
-    return { repos, quants };
+    return { repos, quants, projectorRepos };
 }
 const searchSchema = {
     idField: "repo",
@@ -46,6 +49,7 @@ export async function runSearchCommand(query, options, _command) {
             likes: r.likes,
             gated: r.gated ? "yes" : "",
             installed: repos.has(r.repo.toLowerCase()),
+            summary: r.summary,
         })),
         schema: searchSchema,
     };
@@ -73,6 +77,8 @@ export function addAddOptions(cmd) {
         .description("Download a model from an arbitrary Hugging Face repo")
         .argument("<repo>", "owner/repo on Hugging Face")
         .option("--quant <label>", "quantization to download (e.g. Q5_K_M)")
+        .option("--component <id...>", "download optional discovered component ids")
+        .option("--primary-only", "download only the selected primary quant")
         .option("--list-quants", "list the quantizations the repo offers and exit");
 }
 export async function runAddCommand(repo, options, _command) {
@@ -80,7 +86,7 @@ export async function runAddCommand(repo, options, _command) {
     const token = resolveHfToken(config);
     const { quants, mmproj } = await listRepoQuants(repo, token);
     if (options.listQuants || !options.quant) {
-        const { quants: installedQuants } = installedIndex(config);
+        const { quants: installedQuants, projectorRepos } = installedIndex(config);
         const listing = {
             type: "list",
             data: quants.map((q) => ({
@@ -88,7 +94,17 @@ export async function runAddCommand(repo, options, _command) {
                 size: formatBytes(q.sizeBytes),
                 sizeBytes: q.sizeBytes,
                 files: q.files.length,
+                modelId: installedQuants.get(`${repo.toLowerCase()} ${q.quant.toUpperCase()}`) ?? null,
                 installed: installedQuants.has(`${repo.toLowerCase()} ${q.quant.toUpperCase()}`),
+                ...(mmproj
+                    ? {
+                        projector: {
+                            file: mmproj.files[0],
+                            sizeBytes: mmproj.sizeBytes,
+                            installed: projectorRepos.has(repo.toLowerCase()),
+                        },
+                    }
+                    : {}),
             })),
             schema: addQuantSchema,
         };
@@ -104,8 +120,18 @@ export async function runAddCommand(repo, options, _command) {
             message: `${repo} has no ${options.quant} - available: ${quants.map((q) => q.quant).join(", ") || "none"}`,
         });
     }
-    const files = [...choice.files, ...(mmproj ? mmproj.files : [])];
-    const total = choice.sizeBytes + (mmproj?.sizeBytes ?? 0);
+    const requested = new Set(options.component ?? []);
+    const unknown = [...requested].filter((id) => id !== "vision-projector");
+    if (unknown.length)
+        throw new CommandError({
+            code: "NO_COMPONENT",
+            message: `unknown bundle components: ${unknown.join(", ")}`,
+        });
+    const includeProjector = Boolean(mmproj) &&
+        (requested.has("vision-projector") ||
+            (!options.primaryOnly && options.component === undefined));
+    const files = [...choice.files, ...(includeProjector ? mmproj.files : [])];
+    const total = choice.sizeBytes + (includeProjector ? mmproj.sizeBytes : 0);
     let lastPct = -1;
     const written = await downloadRepoFiles({
         repo,
@@ -114,7 +140,10 @@ export async function runAddCommand(repo, options, _command) {
         token,
         onProgress: (p) => {
             const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
-            if (pct !== lastPct && pct % 5 === 0) {
+            // A download chunk can jump straight over a five-percent boundary.
+            // Report each new integer percent so the UI ring never stalls until
+            // completion simply because no chunk hit an exact multiple of five.
+            if (pct > lastPct) {
                 lastPct = pct;
                 process.stderr.write(`  ${repo} ${choice.quant}: ${pct}%\r`);
             }

package/dist/config/profile-edit.d.ts

@@ -83,7 +83,7 @@ export interface SanitizeResult {
  * Apply an editable patch to a profile, clamping every field to its range and
  * dropping anything the model cannot use.
  *
- * Only the eight editable keys are honoured. `modelPath`/`mmprojPath`/`modelId`
+ * Only the supported editable keys are honoured. `modelPath`/`mmprojPath`/`modelId`
  * are re-derived from the model on every read (`profiles.forModel`), so letting
  * a caller set them would be a lie at best and a path-traversal at worst.
  * `reasoningBudgetMessage`, `batchSize`, `ubatchSize` and `extraArgs` stay

package/dist/config/profile-edit.js

@@ -54,8 +54,11 @@ export function nativeContextLimit(model) {
 }
 /** The editable fields, resolved against one model's capabilities. */
 export function profileFieldDescriptors(model) {
-    const hasProjector = Boolean(model?.mmprojPath);
-    return [
+    const projector = model?.components?.find((component) => component.role === "vision_projector");
+    const hasProjector = model?.components
+        ? Boolean(projector?.available)
+        : Boolean(model?.mmprojPath);
+    const fields = [
         {
             key: "contextSize",
             label: "Context",
@@ -80,13 +83,6 @@ export function profileFieldDescriptors(model) {
             available: true,
         },
         { key: "flashAttention", label: "Flash attention", kind: "toggle", available: true },
-        {
-            key: "vision",
-            label: "Vision",
-            kind: "toggle",
-            available: hasProjector,
-            ...(hasProjector ? {} : { unavailableReason: "no projector" }),
-        },
         {
             key: "reasoningBudget",
             label: "Reasoning budget",
@@ -115,6 +111,23 @@ export function profileFieldDescriptors(model) {
             available: true,
         },
     ];
+    // Bundle models expose the projector in the component section below. Keep
+    // the legacy profile field for hand-scanned single-file models, but do not
+    // render two controls that write the same vision setting for bundles.
+    if (!model?.components) {
+        fields.splice(4, 0, {
+            key: "vision",
+            label: "Vision",
+            kind: "toggle",
+            available: hasProjector,
+            ...(hasProjector
+                ? {}
+                : {
+                    unavailableReason: projector ? "download the vision component first" : "no projector",
+                }),
+        });
+    }
+    return fields;
 }
 /** Whether a KV cache type is quantised (anything that is not a float type). */
 function isQuantised(cacheType) {
@@ -186,7 +199,7 @@ function clamp(value, min, max) {
  * Apply an editable patch to a profile, clamping every field to its range and
  * dropping anything the model cannot use.
  *
- * Only the eight editable keys are honoured. `modelPath`/`mmprojPath`/`modelId`
+ * Only the supported editable keys are honoured. `modelPath`/`mmprojPath`/`modelId`
  * are re-derived from the model on every read (`profiles.forModel`), so letting
  * a caller set them would be a lie at best and a path-traversal at worst.
  * `reasoningBudgetMessage`, `batchSize`, `ubatchSize` and `extraArgs` stay
@@ -264,6 +277,23 @@ export function sanitizeProfilePatch(current, patch, model) {
             next.vision = p.vision;
         }
     }
+    if ("enabledComponents" in p) {
+        if (!Array.isArray(p.enabledComponents) ||
+            !p.enabledComponents.every((id) => typeof id === "string")) {
+            throw new Error("enabledComponents must be an array of component ids");
+        }
+        const requested = [...new Set(p.enabledComponents)];
+        const available = new Set(model?.components
+            ?.filter((component) => component.available)
+            .map((component) => component.id) ?? []);
+        const unavailable = requested.filter((id) => !available.has(id));
+        if (unavailable.length)
+            throw new Error(`components are not downloaded: ${unavailable.join(", ")}`);
+        next.enabledComponents = requested;
+        const projector = model?.components?.find((component) => component.role === "vision_projector" && requested.includes(component.id));
+        if (model?.components)
+            next.vision = Boolean(projector);
+    }
     return { profile: next, adjustments };
 }
 //# sourceMappingURL=profile-edit.js.map

package/dist/config/profiles.js

@@ -2,6 +2,14 @@ import { DEFAULT_REASONING_MESSAGE, } from "./schema.js";
 export function defaultProfile(model, defaults) {
     const nativeContext = model?.metadata?.contextLength || 32768;
     const contextCap = defaults?.contextCap ?? 225000;
+    const enabledComponents = model?.components
+        ? model.components
+            .filter((component) => component.available && component.defaultLoad)
+            .map((component) => component.id)
+        : [];
+    const componentPaths = Object.fromEntries((model?.components ?? [])
+        .filter((component) => enabledComponents.includes(component.id) && component.path)
+        .map((component) => [component.role, component.path]));
     return {
         modelId: model?.id ?? null,
         modelPath: model?.modelPath ?? null,
@@ -13,7 +21,13 @@ export function defaultProfile(model, defaults) {
         cacheTypeV: defaults?.cacheTypeV ?? "q8_0",
         flashAttention: defaults?.flashAttention ?? true, // required for a quantised V cache
         gpuLayers: 999, // everything on GPU; the budget check guards this
-        vision: Boolean(model?.mmprojPath),
+        // Existing hand-scanned models keep the historical vision default. Bundles
+        // instead opt in only to installed components whose manifest says so.
+        enabledComponents,
+        componentPaths,
+        vision: model?.components
+            ? model.components.some((component) => component.role === "vision_projector" && component.available && component.defaultLoad)
+            : Boolean(model?.mmprojPath),
         reasoningBudget: defaults?.reasoningBudget ?? 1536,
         reasoningBudgetMessage: DEFAULT_REASONING_MESSAGE,
         parallelSlots: defaults?.parallelSlots ?? 1, // one agent at a time: max context per request
@@ -29,7 +43,27 @@ export function forModel(store, model, defaults) {
     if (!stored)
         return base;
     // Paths are re-derived so a moved model library does not break the profile.
-    return { ...base, ...stored, modelPath: model.modelPath, mmprojPath: model.mmprojPath };
+    const enabledComponents = (stored.enabledComponents ?? []).filter((id) => model.components?.some((component) => component.id === id && component.available));
+    // COMPAT(bundleProfiles): added in v0.8.7, remove after 2027-02-11.
+    // Old vision profiles become the manifest's vision component when it exists.
+    if (model.components && enabledComponents.length === 0 && stored.vision) {
+        enabledComponents.push(...model.components
+            .filter((component) => component.role === "vision_projector" && component.available)
+            .map((component) => component.id));
+    }
+    const mmproj = model.components?.find((component) => component.role === "vision_projector" && enabledComponents.includes(component.id));
+    const componentPaths = Object.fromEntries((model.components ?? [])
+        .filter((component) => enabledComponents.includes(component.id) && component.path)
+        .map((component) => [component.role, component.path]));
+    return {
+        ...base,
+        ...stored,
+        enabledComponents,
+        modelPath: model.modelPath,
+        mmprojPath: mmproj?.path ?? (model.components ? null : model.mmprojPath),
+        componentPaths,
+        vision: model.components ? Boolean(mmproj) : stored.vision,
+    };
 }
 export function put(store, model, profile) {
     store.profiles[model.id] = { ...profile, modelId: model.id };
@@ -37,7 +71,13 @@ export function put(store, model, profile) {
 }
 /** Calibration is keyed by cache types, since those change bytes/token. */
 export function calibrationKey(profile) {
-    return `${profile.cacheTypeK}:${profile.cacheTypeV}`;
+    const components = [...(profile.enabledComponents ?? [])].sort();
+    // COMPAT(bundleCalibrationKey): added in v0.8.7, remove after 2027-02-11.
+    // A main-model-only load remains the historical identity; any enabled bundle
+    // artifact gets a distinct key and therefore cannot claim that measurement.
+    return components.length
+        ? `${profile.cacheTypeK}:${profile.cacheTypeV}:components=${components.join(",")}`
+        : `${profile.cacheTypeK}:${profile.cacheTypeV}`;
 }
 /**
  * True when this model has a stored calibration, but for different cache types
@@ -95,21 +135,37 @@ export function getCalibration(store, model, profile) {
 export function putCalibration(store, model, profile, measurement) {
     if (!store.calibrations)
         store.calibrations = {};
-    if (!store.calibrations[model.id])
-        store.calibrations[model.id] = {};
-    store.calibrations[model.id][calibrationKey(profile)] = measurement;
+    const calibrations = store.calibrations;
+    if (!Object.hasOwn(calibrations, model.id)) {
+        Object.defineProperty(calibrations, model.id, {
+            configurable: true,
+            enumerable: true,
+            value: {},
+        });
+    }
+    Object.defineProperty(calibrations[model.id], calibrationKey(profile), {
+        configurable: true,
+        enumerable: true,
+        value: measurement,
+        writable: true,
+    });
     const key = geometryKey(model, profile);
     const layers = model?.metadata?.blockCount;
     if (key && layers) {
         if (!store.geometryCalibrations)
             store.geometryCalibrations = {};
-        store.geometryCalibrations[key] = {
-            kvBytesPerTokenPerLayer: measurement.kvBytesPerToken / layers,
-            baseOverheadBytes: measurement.baseOverheadBytes,
-            measuredAt: measurement.measuredAt,
-            measuredOn: model.displayName,
-            measuredLayers: layers,
-        };
+        Object.defineProperty(store.geometryCalibrations, key, {
+            configurable: true,
+            enumerable: true,
+            value: {
+                kvBytesPerTokenPerLayer: measurement.kvBytesPerToken / layers,
+                baseOverheadBytes: measurement.baseOverheadBytes,
+                measuredAt: measurement.measuredAt,
+                measuredOn: model.displayName,
+                measuredLayers: layers,
+            },
+            writable: true,
+        });
     }
     return store;
 }