@otto-code/brain 0.8.7 → 0.8.9

package/dist/config/hosting-profiles.d.ts

@@ -0,0 +1,33 @@
+import type { BrainPaths } from "./paths.js";
+import type { HostingProfile, Profile, ProfilesStore } from "./schema.js";
+/**
+ * The bucket a model's hosting profiles live in. Families are catalog-authoritative
+ * when available, otherwise discovery derives them from GGUF metadata; models
+ * with neither use one real bucket rather than each being unaddressable. This
+ * must be the single definition: a writer that stored under "generic" while a
+ * reader looked up `null` was why a family default could be set on an unfamilied
+ * model and never take effect.
+ */
+export declare const GENERIC_HOSTING_FAMILY = "generic";
+export declare function hostingFamily(family: string | null | undefined): string;
+export declare function familyHostingProfileId(store: ProfilesStore, family: string | null | undefined): string | null;
+export declare function effectiveHostingProfile(store: ProfilesStore, profile: Profile, family: string | null | undefined): HostingProfile | null;
+/**
+ * Materialize a selected profile immediately before launch: the template as a
+ * file llama-server reads, the system addendum as a string the router injects
+ * into each completion request.
+ *
+ * The addendum is deliberately *not* spliced into the Jinja template, which was
+ * the first design. Doing that means rewriting the `messages` list from inside
+ * the template, and there is no portable way to do it: minja's support for list
+ * mutation differs from Jinja2's, every model family's template consumes the
+ * system turn differently, and a message's `content` is an array of parts for
+ * multimodal requests rather than a string to concatenate onto. Injecting into
+ * the parsed request body is the same composition (it appends to the agent's
+ * existing system message instead of replacing it) done where the shape is
+ * known and testable.
+ */
+export declare function resolveHostingProfileForLaunch(paths: BrainPaths, store: ProfilesStore, profile: Profile, family: string | null | undefined): Profile;
+/** Remove a deleted profile's generated template. Missing or locked files are non-fatal. */
+export declare function removeHostingProfileMaterialization(paths: BrainPaths, id: string): void;
+//# sourceMappingURL=hosting-profiles.d.ts.map

package/dist/config/hosting-profiles.js

@@ -0,0 +1,71 @@
+/** Brain-owned named chat-template compositions for llama-server. */
+import { rmSync } from "node:fs";
+import path from "node:path";
+import { writePrivateFileAtomicSync } from "./private-files.js";
+const SAFE_FILE = /[^a-zA-Z0-9_-]/gu;
+function materializedTemplatePath(paths, id) {
+    return path.join(paths.templatesDir, `${id.replace(SAFE_FILE, "_")}.jinja`);
+}
+/**
+ * The bucket a model's hosting profiles live in. Families are catalog-authoritative
+ * when available, otherwise discovery derives them from GGUF metadata; models
+ * with neither use one real bucket rather than each being unaddressable. This
+ * must be the single definition: a writer that stored under "generic" while a
+ * reader looked up `null` was why a family default could be set on an unfamilied
+ * model and never take effect.
+ */
+export const GENERIC_HOSTING_FAMILY = "generic";
+export function hostingFamily(family) {
+    return family || GENERIC_HOSTING_FAMILY;
+}
+export function familyHostingProfileId(store, family) {
+    return store.familyHostingProfileIds[hostingFamily(family)] ?? null;
+}
+export function effectiveHostingProfile(store, profile, family) {
+    const selected = profile.hostingProfileMode === "inherit"
+        ? familyHostingProfileId(store, family)
+        : profile.hostingProfileMode === "custom"
+            ? profile.hostingProfileId
+            : null;
+    return selected ? (store.hostingProfiles[selected] ?? null) : null;
+}
+/**
+ * Materialize a selected profile immediately before launch: the template as a
+ * file llama-server reads, the system addendum as a string the router injects
+ * into each completion request.
+ *
+ * The addendum is deliberately *not* spliced into the Jinja template, which was
+ * the first design. Doing that means rewriting the `messages` list from inside
+ * the template, and there is no portable way to do it: minja's support for list
+ * mutation differs from Jinja2's, every model family's template consumes the
+ * system turn differently, and a message's `content` is an array of parts for
+ * multimodal requests rather than a string to concatenate onto. Injecting into
+ * the parsed request body is the same composition (it appends to the agent's
+ * existing system message instead of replacing it) done where the shape is
+ * known and testable.
+ */
+export function resolveHostingProfileForLaunch(paths, store, profile, family) {
+    const selected = effectiveHostingProfile(store, profile, family);
+    const chatSystemAddendum = selected?.systemPromptAddendum?.trim() || null;
+    if (!selected?.template) {
+        return { ...profile, chatTemplateFile: null, chatTemplateKwargs: {}, chatSystemAddendum };
+    }
+    const file = materializedTemplatePath(paths, selected.id);
+    writePrivateFileAtomicSync(file, selected.template);
+    return {
+        ...profile,
+        chatTemplateFile: file,
+        chatTemplateKwargs: selected.templateKwargs,
+        chatSystemAddendum,
+    };
+}
+/** Remove a deleted profile's generated template. Missing or locked files are non-fatal. */
+export function removeHostingProfileMaterialization(paths, id) {
+    try {
+        rmSync(materializedTemplatePath(paths, id), { force: true });
+    }
+    catch {
+        // Profile deletion must not fail because a previous launch left a file locked.
+    }
+}
+//# sourceMappingURL=hosting-profiles.js.map

package/dist/config/index.d.ts

@@ -5,6 +5,7 @@ export { resolveBrainPaths, packageRoot, type BrainPaths } from "./paths.js";
 export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
 export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
+export { effectiveHostingProfile, resolveHostingProfileForLaunch } from "./hosting-profiles.js";
 export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, type CalibrationInfo, type CalibrationState, type ProfileFieldDescriptor, type ProfileWarning, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -5,6 +5,7 @@ export { resolveBrainPaths, packageRoot } from "./paths.js";
 export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
 export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
+export { effectiveHostingProfile, resolveHostingProfileForLaunch } from "./hosting-profiles.js";
 export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.js.map

package/dist/config/paths.d.ts

@@ -12,6 +12,8 @@ export interface BrainPaths {
     logFile: string;
     logsDir: string;
     resultsDir: string;
+    /** Brain-owned Jinja files materialized from named hosting profiles. */
+    templatesDir: string;
 }
 export declare function resolveBrainPaths(env?: NodeJS.ProcessEnv): BrainPaths;
 /**

package/dist/config/paths.js

@@ -26,6 +26,7 @@ export function resolveBrainPaths(env = process.env) {
         logFile: path.join(root, "otto-brain.log"),
         logsDir: path.join(root, "logs"),
         resultsDir: path.join(root, "results"),
+        templatesDir: path.join(root, "templates"),
     };
 }
 /**

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

@@ -45,10 +45,12 @@ export declare const MAX_PARALLEL_SLOTS = 16;
 export declare const MAX_GPU_LAYERS = 999;
 export declare const MIN_CONTEXT_SIZE = 1024;
 export declare const CONTEXT_STEP = 8192;
+export declare const CONTEXT_MULTIPLIERS: number[];
 /** The context ceiling: the model's native window, or a generous bound if unknown. */
 export declare function nativeContextLimit(model: Model | null): number;
+export declare function contextLimit(model: Model | null, multiplier?: number): number;
 /** The editable fields, resolved against one model's capabilities. */
-export declare function profileFieldDescriptors(model: Model | null): ProfileFieldDescriptor[];
+export declare function profileFieldDescriptors(model: Model | null, profile?: Profile | null): ProfileFieldDescriptor[];
 /** A note attached to a field, or to the profile as a whole when `field` is null. */
 export interface ProfileWarning {
     field: string | null;
@@ -83,12 +85,12 @@ 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
  * CLI-only: they have no measured effect worth exposing and `extraArgs` is
  * arbitrary process arguments.
  */
-export declare function sanitizeProfilePatch(current: Profile, patch: unknown, model: Model | null): SanitizeResult;
+export declare function sanitizeProfilePatch(current: Profile, patch: unknown, model: Model | null, runtimeBuild?: number | null): SanitizeResult;
 //# sourceMappingURL=profile-edit.d.ts.map

package/dist/config/profile-edit.js

@@ -47,22 +47,38 @@ export const MAX_PARALLEL_SLOTS = 16;
 export const MAX_GPU_LAYERS = 999;
 export const MIN_CONTEXT_SIZE = 1024;
 export const CONTEXT_STEP = 8192;
+export const CONTEXT_MULTIPLIERS = [1, 2, 4];
 /** The context ceiling: the model's native window, or a generous bound if unknown. */
 export function nativeContextLimit(model) {
     const native = model?.metadata?.contextLength;
     return typeof native === "number" && native > 0 ? native : 1000000;
 }
+export function contextLimit(model, multiplier = 1) {
+    return nativeContextLimit(model) * multiplier;
+}
 /** The editable fields, resolved against one model's capabilities. */
-export function profileFieldDescriptors(model) {
-    const hasProjector = Boolean(model?.mmprojPath);
-    return [
+export function profileFieldDescriptors(model, profile) {
+    const projector = model?.components?.find((component) => component.role === "vision_projector");
+    const hasProjector = model?.components
+        ? Boolean(projector?.available)
+        : Boolean(model?.mmprojPath);
+    const fields = [
+        {
+            key: "contextMultiplier",
+            label: "Context multiplier",
+            kind: "cycle",
+            options: CONTEXT_MULTIPLIERS,
+            optionLabels: ["Off", "2× (YaRN)", "4× (YaRN)"],
+            available: Boolean(model?.metadata?.contextLength),
+            ...(model?.metadata?.contextLength ? {} : { unavailableReason: "native context unknown" }),
+        },
         {
             key: "contextSize",
             label: "Context",
             kind: "number",
             step: CONTEXT_STEP,
             min: MIN_CONTEXT_SIZE,
-            max: nativeContextLimit(model),
+            max: contextLimit(model, profile?.contextMultiplier ?? 1),
             available: true,
         },
         {
@@ -80,13 +96,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 +124,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) {
@@ -147,6 +173,17 @@ export function profileWarnings(profile, model, store) {
             blocksStart: false,
         });
     }
+    if (profile.contextMultiplier > 1) {
+        warnings.push({
+            field: "contextMultiplier",
+            severity: "warn",
+            message: `YaRN ×${profile.contextMultiplier} extrapolates beyond the native context. Recalibrate before relying on this profile.`,
+            blocksStart: false,
+        });
+    }
+    // Distinct from `calibrationRequired`, which says this profile has never been
+    // measured in its current shape. This says a measurement exists but was taken
+    // for other cache types, so it names the reason rather than just the verdict.
     if (model && store && hasStaleCalibration(store, model, profile)) {
         warnings.push({
             field: "cacheTypeK",
@@ -163,6 +200,17 @@ export function profileWarnings(profile, model, store) {
  * model's layer count, which the UI must never present as measured on this file.
  */
 export function calibrationInfo(store, model, profile) {
+    // A historical measurement is invalid as soon as any VRAM-affecting setting
+    // changes. Keep the data for comparison, but do not present or use it as the
+    // current model budget until a calibration commits the new profile.
+    if (profile.calibrationRequired) {
+        return {
+            state: "theoretical",
+            kvBytesPerToken: null,
+            measuredAt: null,
+            measuredOn: null,
+        };
+    }
     const calibration = getCalibration(store, model, profile);
     if (!calibration) {
         return {
@@ -182,18 +230,37 @@ export function calibrationInfo(store, model, profile) {
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
+/** The settings whose value changes what a calibration would measure. */
+const CALIBRATION_INPUTS = [
+    "contextMultiplier",
+    "contextSize",
+    "cacheTypeK",
+    "cacheTypeV",
+    "flashAttention",
+    "gpuLayers",
+    "parallelSlots",
+    "vision",
+    "enabledComponents",
+];
+/** Every calibration input is a scalar except the component id list, which is a set. */
+function sameCalibrationInput(before, after) {
+    if (Array.isArray(before) && Array.isArray(after)) {
+        return [...before].sort().join("\0") === [...after].sort().join("\0");
+    }
+    return before === after;
+}
 /**
  * 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
  * CLI-only: they have no measured effect worth exposing and `extraArgs` is
  * arbitrary process arguments.
  */
-export function sanitizeProfilePatch(current, patch, model) {
+export function sanitizeProfilePatch(current, patch, model, runtimeBuild = null) {
     const adjustments = [];
     const next = { ...current };
     if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
@@ -232,7 +299,14 @@ export function sanitizeProfilePatch(current, patch, model) {
         }
         next[key] = value;
     };
-    takeNumber("contextSize", MIN_CONTEXT_SIZE, nativeContextLimit(model));
+    if ("contextMultiplier" in p) {
+        const raw = p.contextMultiplier;
+        if (typeof raw !== "number" || !CONTEXT_MULTIPLIERS.includes(raw)) {
+            throw new Error("contextMultiplier must be one of 1, 2, or 4");
+        }
+        next.contextMultiplier = raw;
+    }
+    takeNumber("contextSize", MIN_CONTEXT_SIZE, contextLimit(model, next.contextMultiplier));
     takeCacheType("cacheTypeK");
     takeCacheType("cacheTypeV");
     takeBoolean("flashAttention");
@@ -264,6 +338,52 @@ 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 requiredBuild = requested
+            .map((id) => model?.components?.find((component) => component.id === id))
+            .find((component) => component?.minRuntimeBuild !== undefined &&
+            (runtimeBuild === null || runtimeBuild < component.minRuntimeBuild))?.minRuntimeBuild;
+        if (requiredBuild !== undefined) {
+            const active = runtimeBuild === null ? "unknown" : `b${runtimeBuild}`;
+            throw new Error(`components require llama.cpp build b${requiredBuild} or newer (active build: ${active})`);
+        }
+        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);
+    }
+    // A partial patch may lower the multiplier without naming contextSize. Clamp
+    // the saved value after every field has settled so launch args can never keep
+    // an extended context after YaRN has been turned off.
+    const contextSize = clamp(next.contextSize, MIN_CONTEXT_SIZE, contextLimit(model, next.contextMultiplier));
+    if (contextSize !== next.contextSize) {
+        next.contextSize = contextSize;
+        adjustments.push(`contextSize clamped to ${contextSize}`);
+    }
+    // The saved profile carries the calibration verdict. Do not infer it from
+    // whether an old measurement happens to exist: a person who changes settings,
+    // leaves, and returns must still be told to calibrate this new configuration.
+    //
+    // Compare values, never key presence. The editor autosaves the whole draft on
+    // every edit, so every one of these keys is in `p` every time; keying off
+    // presence threw away a real measurement whenever any unrelated field - or a
+    // hosting-profile choice, which does not touch VRAM at all - was saved.
+    const before = current;
+    const after = next;
+    if (CALIBRATION_INPUTS.some((key) => !sameCalibrationInput(before[key], after[key]))) {
+        next.calibrationRequired = true;
+    }
     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,
@@ -9,17 +17,32 @@ export function defaultProfile(model, defaults) {
         // Long context is the point of this hardware; start at the native limit and
         // let the VRAM budget pull it down.
         contextSize: Math.min(nativeContext, contextCap),
+        contextMultiplier: 1,
+        calibrationRequired: true,
         cacheTypeK: defaults?.cacheTypeK ?? "q8_0",
         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
         batchSize: null,
         ubatchSize: null,
         extraArgs: [],
+        hostingProfileId: null,
+        // Inherit, not off: a new model in a family that has a default should use
+        // it. With no family default configured this resolves to nothing anyway.
+        hostingProfileMode: "inherit",
+        chatTemplateFile: null,
+        chatTemplateKwargs: {},
+        chatSystemAddendum: null,
     };
 }
 /** Stored profile for a model, falling back to computed defaults. */
@@ -29,7 +52,36 @@ 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,
+        // COMPAT(hostingProfileMode): added in v0.8.8, remove after 2027-02-12.
+        // The first hosting-profile store only had an id, and a non-null id there
+        // was an explicit custom choice. Such a profile parses as `inherit` (the
+        // schema default), so promote it. Writers hold the inverse invariant - the
+        // id is nulled whenever the mode is not `custom` - so a stored id can only
+        // mean a legacy record, never a stale leftover of a newer explicit choice.
+        hostingProfileMode: stored.hostingProfileId && stored.hostingProfileMode === "inherit"
+            ? "custom"
+            : stored.hostingProfileMode,
+        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 +89,14 @@ 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();
+    const multiplier = profile.contextMultiplier > 1 ? `:contextMultiplier=${profile.contextMultiplier}` : "";
+    // 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}${multiplier}:components=${components.join(",")}`
+        : `${profile.cacheTypeK}:${profile.cacheTypeV}${multiplier}`;
 }
 /**
  * True when this model has a stored calibration, but for different cache types
@@ -127,6 +186,10 @@ export function putCalibration(store, model, profile, measurement) {
             writable: true,
         });
     }
+    // Calibration is a durable verdict about the persisted model profile, not a
+    // transient UI hint. Every completion path (CLI, TUI, and host job) shares
+    // this helper, so clearing it here keeps the state consistent everywhere.
+    put(store, model, { ...profile, calibrationRequired: false });
     return store;
 }
 //# sourceMappingURL=profiles.js.map