@otto-code/brain 0.8.17 → 0.8.19

package/dist/gguf.d.ts

@@ -55,11 +55,20 @@ interface GgufSummary {
     reasoning: boolean;
     /** Native preservation argument, normalized by model enrichment when present. */
     reasoningPreservationArgument?: "preserve_thinking" | "preserve_reasoning";
+    /** Template argument that switches the thinking channel on or off. */
+    reasoningToggleArgument?: string;
+    /** Template argument that carries a graduated effort level. */
+    reasoningEffortArgument?: string;
+    /** Effort levels the template itself names, when it validates a literal set. */
+    reasoningEffortValues?: string[];
 }
 /** Read model-specific template spellings without leaking them into the UI contract. */
 export declare function detectTemplateReasoningCapabilities(chatTemplate: string): {
     reasoning: boolean;
     reasoningPreservationArgument?: "preserve_thinking" | "preserve_reasoning";
+    reasoningToggleArgument?: string;
+    reasoningEffortArgument?: string;
+    reasoningEffortValues?: string[];
 };
 /**
  * Pull out the fields that matter for hosting decisions.

package/dist/gguf.js

@@ -176,6 +176,43 @@ export function readMetadata(file) {
     }
     throw new Error(`could not read GGUF header from ${file}`);
 }
+/** Effort levels Otto can express, in the spelling a chat template uses. */
+const TEMPLATE_EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh"]);
+/** Template argument spellings that switch the thinking channel on or off. */
+const TOGGLE_ARGUMENTS = ["enable_thinking", "enable_reasoning"];
+/** Template argument spellings that carry a graduated effort level. */
+const EFFORT_ARGUMENTS = ["reasoning_effort", "thinking_effort"];
+/**
+ * Pull the effort levels a template names itself, e.g. Qwen3.8's guard clause
+ * `{%- if reasoning_effort not in ['low', 'medium', 'xhigh'] %}`. Only literals
+ * from a list sitting next to the effort argument are trusted: a level this
+ * function invents is one llama.cpp fails the whole completion over.
+ */
+function detectTemplateEffortValues(chatTemplate, effortArgument) {
+    const values = [];
+    let from = 0;
+    for (;;) {
+        const at = chatTemplate.indexOf(effortArgument, from);
+        if (at < 0)
+            break;
+        from = at + effortArgument.length;
+        // The list has to sit in the same expression as the argument, so a window
+        // this short is what keeps an unrelated list elsewhere in the template out.
+        const window = chatTemplate.slice(from, from + 120);
+        const open = window.indexOf("[");
+        const close = window.indexOf("]");
+        if (open < 0 || close < open)
+            continue;
+        for (const literal of window.slice(open + 1, close).matchAll(/["']([a-z]+)["']/giu)) {
+            const value = literal[1].toLowerCase();
+            if (TEMPLATE_EFFORT_LEVELS.has(value) && !values.includes(value))
+                values.push(value);
+        }
+        if (values.length > 0)
+            break;
+    }
+    return values;
+}
 /** Read model-specific template spellings without leaking them into the UI contract. */
 export function detectTemplateReasoningCapabilities(chatTemplate) {
     const reasoningPreservationArgument = /\bpreserve_thinking\b/iu.test(chatTemplate)
@@ -183,10 +220,24 @@ export function detectTemplateReasoningCapabilities(chatTemplate) {
         : /\bpreserve_reasoning\b/iu.test(chatTemplate)
             ? "preserve_reasoning"
             : undefined;
+    // The control contract, read from the template instead of the catalog. An
+    // uncurated GGUF can expose a thinking channel and the argument that steers
+    // it, and without reading that here the model reports a reasoning channel no
+    // Otto control can reach.
+    const reasoningToggleArgument = TOGGLE_ARGUMENTS.find((argument) => chatTemplate.includes(argument));
+    const reasoningEffortArgument = EFFORT_ARGUMENTS.find((argument) => chatTemplate.includes(argument));
+    const reasoningEffortValues = reasoningEffortArgument
+        ? detectTemplateEffortValues(chatTemplate, reasoningEffortArgument)
+        : [];
     return {
         reasoning: Boolean(reasoningPreservationArgument ||
-            /<think>|<\/think>|reasoning_content|enable_thinking/iu.test(chatTemplate)),
+            reasoningToggleArgument ||
+            reasoningEffortArgument ||
+            /<think>|<\/think>|reasoning_content/iu.test(chatTemplate)),
         ...(reasoningPreservationArgument ? { reasoningPreservationArgument } : {}),
+        ...(reasoningToggleArgument ? { reasoningToggleArgument } : {}),
+        ...(reasoningEffortArgument ? { reasoningEffortArgument } : {}),
+        ...(reasoningEffortValues.length > 0 ? { reasoningEffortValues } : {}),
     };
 }
 /**

package/dist/models/enrich.js

@@ -133,16 +133,19 @@ export function enrichWithCatalog(models, catalog) {
             const enriched = enrichDiscoveredProjector(model);
             const family = familyFromGgufMetadata(enriched);
             const reasoningPreservation = detectedReasoningPreservation(enriched);
-            if (!family && !reasoningPreservation)
+            const reasoningControl = detectedReasoningControl(enriched);
+            if (!family && !reasoningPreservation && !reasoningControl)
                 return enriched;
             return {
                 ...enriched,
                 ...(family ? { family } : {}),
                 ...(reasoningPreservation ? { reasoningPreservation } : {}),
+                ...reasoningControl,
             };
         }
         const components = resolveComponents(model, entry);
         const projector = components?.find((component) => component.role === "vision_projector");
+        const reasoningControl = detectedReasoningControl(model);
         return {
             ...model,
             catalogId: entry.id,
@@ -156,14 +159,48 @@ export function enrichWithCatalog(models, catalog) {
             useCases: entry.useCases,
             tier: entry.tier,
             thinking: entry.thinking,
-            reasoningEfforts: entry.reasoningEfforts,
+            // A curated declaration wins, but an entry that only says "this model
+            // thinks" still needs a way to steer it, so fall back to the contract the
+            // chat template states.
+            reasoningEfforts: entry.reasoningEfforts ?? reasoningControl?.reasoningEfforts,
             reasoningEffortDefault: entry.reasoningEffortDefault,
-            reasoningTemplate: entry.reasoningTemplate,
+            reasoningTemplate: entry.reasoningTemplate ?? reasoningControl?.reasoningTemplate,
             reasoningPreservation: entry.reasoningPreservation ?? detectedReasoningPreservation(model),
             contextMax: entry.contextMax,
         };
     });
 }
+/**
+ * The reasoning control contract a model's own chat template declares.
+ *
+ * Otto only shows an Effort control for a model it can actually steer, and it
+ * only forwards a level the template accepts - an unknown value makes llama.cpp
+ * fail the whole completion with a Jinja exception. A template that names a
+ * toggle argument therefore earns a binary On, a template that also validates a
+ * literal level set earns those levels, and a template that merely emits a
+ * `<think>` block earns no control at all.
+ */
+function detectedReasoningControl(model) {
+    const toggleArgument = model.metadata?.reasoningToggleArgument;
+    const effortArgument = model.metadata?.reasoningEffortArgument;
+    if (typeof toggleArgument !== "string" && typeof effortArgument !== "string")
+        return undefined;
+    const declaredValues = model.metadata?.reasoningEffortValues;
+    const levels = typeof effortArgument === "string" && Array.isArray(declaredValues)
+        ? declaredValues.filter((value) => typeof value === "string")
+        : [];
+    return {
+        // Levels when the template names them, otherwise the generic On, which the
+        // router resolves to the template's own default.
+        reasoningEfforts: levels.length > 0 ? levels : ["on"],
+        reasoningTemplate: {
+            // An argument the template never reads is inert in the kwargs payload, so
+            // a placeholder here costs nothing and keeps the toggle path uniform.
+            enableThinkingArgument: toggleArgument ?? "enable_thinking",
+            effortArgument: effortArgument ?? "reasoning_effort",
+        },
+    };
+}
 /** Map the two known template spellings to one model capability. */
 function detectedReasoningPreservation(model) {
     const templateArgument = model.metadata?.reasoningPreservationArgument;

package/dist/models/pick.d.ts

@@ -4,9 +4,8 @@ export declare function pickModel(catalog: Model[], needle: string | undefined):
 /**
  * Choose a model when nothing named one: the best-ranked model from bench
  * history that is still installed, or the first catalog entry when nothing
- * has been benched yet. This is what "Automatic" (a null default model) means
- * in the UI - it must always start something for a non-empty catalog. The
- * VRAM fit check downstream in startService is what can still refuse the pick.
+ * has been benched yet. This is for callers that explicitly request automatic
+ * selection; a null startup default intentionally leaves Brain unloaded.
  */
 export declare function pickAutoModel(catalog: Model[], ranked?: RankedModel[]): Model;
 //# sourceMappingURL=pick.d.ts.map

package/dist/models/pick.js

@@ -37,9 +37,8 @@ export function pickModel(catalog, needle) {
 /**
  * Choose a model when nothing named one: the best-ranked model from bench
  * history that is still installed, or the first catalog entry when nothing
- * has been benched yet. This is what "Automatic" (a null default model) means
- * in the UI - it must always start something for a non-empty catalog. The
- * VRAM fit check downstream in startService is what can still refuse the pick.
+ * has been benched yet. This is for callers that explicitly request automatic
+ * selection; a null startup default intentionally leaves Brain unloaded.
  */
 export function pickAutoModel(catalog, ranked = rankModels()) {
     if (catalog.length === 0) {

package/dist/ops/calibrate.d.ts

@@ -64,6 +64,15 @@ export interface CalibrateOptions {
     internalPort?: number;
     /** Reuse the host's resident supervisor instead of creating a sidecar server. */
     supervisor?: Supervisor;
+    /**
+     * Pool-owned lifecycle for a hosted operation. Both callbacks must be
+     * supplied together; standalone CLI/TUI runs keep using their local
+     * supervisor.
+     */
+    lifecycle?: {
+        start: (profile: Profile) => Promise<void>;
+        stop: () => Promise<void>;
+    };
     /**
      * Pause after stopping each sample so the driver releases its allocation
      * before the next load. Tests run with zero.
@@ -83,5 +92,5 @@ export interface CalibrationMeasurement {
     vision: boolean;
     measuredAt: string;
 }
-export declare function calibrate({ runtime, model, profile, samples, priorCalibration, internalPort, supervisor: optionsSupervisor, releaseDelayMs, onProgress, }: CalibrateOptions): Promise<CalibrationMeasurement>;
+export declare function calibrate({ runtime, model, profile, samples, priorCalibration, internalPort, supervisor: optionsSupervisor, lifecycle, releaseDelayMs, onProgress, }: CalibrateOptions): Promise<CalibrationMeasurement>;
 //# sourceMappingURL=calibrate.d.ts.map

package/dist/ops/calibrate.js

@@ -27,7 +27,7 @@ export function maxContextForCalibration(model, profile, calibration, totalVramB
     });
     return max && max >= 4096 ? max : null;
 }
-export async function calibrate({ runtime, model, profile, samples, priorCalibration = null, internalPort = DEFAULT_INTERNAL_PORT + 1, supervisor: optionsSupervisor, releaseDelayMs = 3000, onProgress = () => { }, }) {
+export async function calibrate({ runtime, model, profile, samples, priorCalibration = null, internalPort = DEFAULT_INTERNAL_PORT + 1, supervisor: optionsSupervisor, lifecycle, releaseDelayMs = 3000, onProgress = () => { }, }) {
     const nativeContext = model.metadata?.contextLength ?? null;
     const nativeCeiling = nativeContext ? nativeContext * profile.contextMultiplier : null;
     const gpu = (await query());
@@ -63,6 +63,9 @@ export async function calibrate({ runtime, model, profile, samples, priorCalibra
         throw new Error("calibration needs at least two context sizes");
     const native = nativeCeiling ?? Math.max(...effectiveSamples);
     const points = [];
+    if (lifecycle && !optionsSupervisor) {
+        throw new Error("a managed calibration lifecycle requires its resident supervisor");
+    }
     for (const contextSize of effectiveSamples) {
         if (contextSize > native) {
             onProgress({ phase: "skip", contextSize, reason: `exceeds configured context ${native}` });
@@ -72,7 +75,11 @@ export async function calibrate({ runtime, model, profile, samples, priorCalibra
         onProgress({ phase: "loading", contextSize });
         const baseline = await usedBytes();
         try {
-            await supervisor.start(model, { ...profile, contextSize });
+            const sampleProfile = { ...profile, contextSize };
+            if (lifecycle)
+                await lifecycle.start(sampleProfile);
+            else
+                await supervisor.start(model, sampleProfile);
             if (kvSpilledToCpu(supervisor.logLines)) {
                 const reason = `KV cache split to CPU at ${contextSize.toLocaleString()} context`;
                 onProgress({ phase: "failed", contextSize, reason });
@@ -92,7 +99,10 @@ export async function calibrate({ runtime, model, profile, samples, priorCalibra
             throw error;
         }
         finally {
-            await supervisor.stop();
+            if (lifecycle)
+                await lifecycle.stop();
+            else
+                await supervisor.stop();
             // Let the driver actually release the allocation before the next sample.
             if (releaseDelayMs > 0)
                 await new Promise((resolve) => setTimeout(resolve, releaseDelayMs));

package/dist/ops/sweep.d.ts

@@ -84,9 +84,14 @@ export interface SweepOptions {
     internalPort?: number;
     /** Reuse the host's resident supervisor instead of creating a sidecar server. */
     supervisor?: Supervisor;
+    /** Pool-owned lifecycle for hosted runs; standalone runs use their local supervisor. */
+    lifecycle?: {
+        start: (profile: Profile) => Promise<void>;
+        stop: () => Promise<void>;
+    };
     onProgress?: (event: SweepProgress) => void;
 }
-export declare function sweep({ runtime, model, profile, budgets, maxTokens, temperature, internalPort, supervisor: optionsSupervisor, onProgress, }: SweepOptions): Promise<SweepReport>;
+export declare function sweep({ runtime, model, profile, budgets, maxTokens, temperature, internalPort, supervisor: optionsSupervisor, lifecycle, onProgress, }: SweepOptions): Promise<SweepReport>;
 /**
  * Rank a sweep's trials, best first. `ranked[0].budget` is the recommendation.
  *

package/dist/ops/sweep.js

@@ -95,13 +95,20 @@ export async function runTrial({ supervisor, maxTokens, temperature, }) {
         contentPerSecond: elapsedSeconds > 0 ? content.length / elapsedSeconds : 0,
     };
 }
-export async function sweep({ runtime, model, profile, budgets = DEFAULT_BUDGETS, maxTokens = 8192, temperature = 0.7, internalPort = DEFAULT_INTERNAL_PORT + 2, supervisor: optionsSupervisor, onProgress = () => { }, }) {
+export async function sweep({ runtime, model, profile, budgets = DEFAULT_BUDGETS, maxTokens = 8192, temperature = 0.7, internalPort = DEFAULT_INTERNAL_PORT + 2, supervisor: optionsSupervisor, lifecycle, onProgress = () => { }, }) {
     const results = [];
+    if (lifecycle && !optionsSupervisor) {
+        throw new Error("a managed sweep lifecycle requires its resident supervisor");
+    }
     for (const budget of budgets) {
         const supervisor = optionsSupervisor ?? new Supervisor({ runtime, internalPort });
         onProgress({ phase: "loading", budget });
         try {
-            await supervisor.start(model, { ...profile, reasoningBudget: budget });
+            const trialProfile = { ...profile, reasoningBudget: budget };
+            if (lifecycle)
+                await lifecycle.start(trialProfile);
+            else
+                await supervisor.start(model, trialProfile);
             onProgress({ phase: "generating", budget });
             const trial = await runTrial({ supervisor, maxTokens, temperature });
             results.push({ budget, ...trial, error: null });
@@ -119,7 +126,10 @@ export async function sweep({ runtime, model, profile, budgets = DEFAULT_BUDGETS
             onProgress({ phase: "failed", budget, error: message });
         }
         finally {
-            await supervisor.stop();
+            if (lifecycle)
+                await lifecycle.stop();
+            else
+                await supervisor.stop();
             await new Promise((resolve) => setTimeout(resolve, 2500));
         }
     }

package/dist/runtime/index.d.ts

@@ -3,6 +3,7 @@ import type { Runtime } from "../types.js";
 import { type InstallProgress, type RuntimeTarget } from "./managed.js";
 export { BACKENDS_DIR, LMSTUDIO_ROOT, listRuntimes as listLmStudioRuntimes } from "./lmstudio.js";
 export { buildArgs, buildEnv, formatCommand, type ServeTarget } from "./args.js";
+export { llamaCppRuntimeDriver, type ModelServerDriverLaunchInput, type ModelServerLaunch, type ModelServerRuntimeDriver, } from "./model-server-driver.js";
 export { installManagedRuntime, removeManagedRuntime, listManagedRuntimes, listRuntimeDevices, verifyRuntimeExecutable, defaultRuntimeSpec, extractArchive, resolveRuntimeVariant, serverExeName, supportedVariants, DEFAULT_LLAMA_BUILD, listRuntimeReleases, latestRuntimeBuild, resolveLatestBuildOrPin, MissingAssetError, type ResolvedBuild, type RuntimeRelease, type RuntimeSpec, type RuntimeTarget, type RuntimeVariant, type InstallProgress, } from "./managed.js";
 /** Every runtime available on this machine, managed first then LM Studio. */
 export declare function listAllRuntimes(env?: NodeJS.ProcessEnv): Runtime[];

package/dist/runtime/index.js

@@ -16,6 +16,7 @@ import { listRuntimes as listLmStudioRuntimes, resolveOverride } from "./lmstudi
 import { defaultRuntimeSpec, installManagedRuntime, listManagedRuntimes, } from "./managed.js";
 export { BACKENDS_DIR, LMSTUDIO_ROOT, listRuntimes as listLmStudioRuntimes } from "./lmstudio.js";
 export { buildArgs, buildEnv, formatCommand } from "./args.js";
+export { llamaCppRuntimeDriver, } from "./model-server-driver.js";
 export { installManagedRuntime, removeManagedRuntime, listManagedRuntimes, listRuntimeDevices, verifyRuntimeExecutable, defaultRuntimeSpec, extractArchive, resolveRuntimeVariant, serverExeName, supportedVariants, DEFAULT_LLAMA_BUILD, listRuntimeReleases, latestRuntimeBuild, resolveLatestBuildOrPin, MissingAssetError, } from "./managed.js";
 /** Every runtime available on this machine, managed first then LM Studio. */
 export function listAllRuntimes(env = process.env) {

package/dist/runtime/model-server-driver.d.ts

@@ -0,0 +1,42 @@
+import type { Calibration, Profile } from "../config/schema.js";
+import type { BrainPaths } from "../config/paths.js";
+import type { Model, Runtime } from "../types.js";
+export interface ModelServerLaunch {
+    executable: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    command: string;
+    readinessPath: string;
+    propertiesPath: string | null;
+    formatLogLine(line: string): string;
+}
+export interface ModelServerDriverLaunchInput {
+    runtime: Runtime;
+    model: Model;
+    profile: Profile;
+    calibration: Calibration | null;
+    paths: BrainPaths;
+    host: string;
+    port: number;
+    logVerbosity: number;
+}
+/**
+ * Driver mechanics live here; the host owns process supervision, security,
+ * scheduler admission, status events, and the stable public endpoint.
+ */
+export interface ModelServerRuntimeDriver {
+    readonly id: string;
+    readonly displayName: string;
+    /** Native process name for engine-originated diagnostics. */
+    readonly processName: string;
+    describeProcessExit(input: {
+        code: number | null;
+        signal: NodeJS.Signals | null;
+    }): string;
+    describeLaunchError(error: Error): string;
+    createLaunch(input: ModelServerDriverLaunchInput): ModelServerLaunch;
+}
+/** The first driver preserves the existing managed llama.cpp launch exactly. */
+export declare const llamaCppRuntimeDriver: ModelServerRuntimeDriver;
+//# sourceMappingURL=model-server-driver.d.ts.map

package/dist/runtime/model-server-driver.js

@@ -0,0 +1,50 @@
+/**
+ * The narrow, observed seam between the Brain host and a model-server engine.
+ *
+ * This intentionally starts with launch and introspection only. A method joins
+ * this contract when the common host needs the behavior from more than one
+ * driver; naming every current llama.cpp flag as a generic operation would
+ * create a false lowest common denominator before a second engine exists.
+ */
+import path from "node:path";
+import { mkdirSync } from "node:fs";
+import { buildArgs, buildEnv, formatCommand } from "./args.js";
+import { formatLlamaServerLog } from "../service/log-format.js";
+/** The first driver preserves the existing managed llama.cpp launch exactly. */
+export const llamaCppRuntimeDriver = {
+    id: "llama.cpp",
+    displayName: "llama.cpp",
+    processName: "llama-server",
+    describeProcessExit({ code, signal }) {
+        // 3221225781 == 0xC0000135 STATUS_DLL_NOT_FOUND: the vendor DLL trap.
+        const hint = code === 3221225781 ? " (missing runtime DLLs - the vendor directory was not on PATH)" : "";
+        return `llama-server exited with code ${code}${signal ? ` signal ${signal}` : ""}${hint}`;
+    },
+    describeLaunchError(error) {
+        return `could not launch llama-server: ${error.message}`;
+    },
+    createLaunch({ runtime, model, profile, calibration, paths, host, port, logVerbosity }) {
+        // llama.cpp enables scheduler-required slot erasure only when this existing
+        // directory is passed at launch. Failure to create it preserves the old
+        // behavior rather than making model startup fail for a cleanup feature.
+        const slotSavePath = path.join(paths.root, "slot-saves");
+        try {
+            mkdirSync(slotSavePath, { recursive: true });
+        }
+        catch {
+            /* launch without native slot actions */
+        }
+        const args = buildArgs({ ...profile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port, host, logVerbosity, slotSavePath }, model, calibration);
+        return {
+            executable: runtime.exe,
+            args,
+            cwd: runtime.dir,
+            env: buildEnv(runtime),
+            command: formatCommand(runtime, args),
+            readinessPath: "/health",
+            propertiesPath: "/props",
+            formatLogLine: formatLlamaServerLog,
+        };
+    },
+};
+//# sourceMappingURL=model-server-driver.js.map

package/dist/service/process-pool.d.ts

@@ -1,3 +1,4 @@
+import type { Profile } from "../config/schema.js";
 import type { Model } from "../types.js";
 import type { ModelScheduler, SchedulerStats, SchedulerSubmitOptions } from "./scheduler.js";
 import { Scheduler } from "./scheduler.js";
@@ -8,10 +9,23 @@ export interface ModelProcessPoolOptions {
     createSupervisor: (index: number) => Supervisor;
     createScheduler: (supervisor: Supervisor, loadModel: (model: Model) => Promise<void>, onChange: () => void) => Scheduler<Supervisor>;
     /** Returns the complete VRAM reservation for the process after it is ready. */
-    loadModel: (supervisor: Supervisor, model: Model, reservedElsewhereBytes: number) => Promise<number>;
+    loadModel: (supervisor: Supervisor, model: Model, reservedElsewhereBytes: number, profile?: Profile) => Promise<number>;
     onChange?: (() => void) | null;
     logger?: ((message: string) => void) | null;
 }
+/**
+ * The only lifecycle surface exposed to a resident host operation.
+ *
+ * Calibration and sweep need to relaunch their target with temporary profiles.
+ * Keeping those launches on the pool-owned lease means process limits, VRAM
+ * reservations, eviction state, scheduler slot ownership, and status updates
+ * all observe the same lifecycle.
+ */
+export interface ManagedModelProcess {
+    supervisor: Supervisor;
+    start: (profile: Profile) => Promise<void>;
+    stop: () => Promise<void>;
+}
 /**
  * Global admission and eviction boundary for independently hosted models.
  *
@@ -27,6 +41,8 @@ export declare class ModelProcessPool implements ModelScheduler<Supervisor> {
     constructor(options: ModelProcessPoolOptions);
     get maxModels(): number;
     submit(model: Model, run: (supervisor: Supervisor) => Promise<unknown>, options?: SchedulerSubmitOptions): Promise<unknown>;
+    /** Run an exclusive operation with pool-owned model lifecycle controls. */
+    submitOperation(model: Model, run: (process: ManagedModelProcess) => Promise<unknown>, options: SchedulerSubmitOptions): Promise<unknown>;
     /** Load a model and leave it resident without consuming an inference slot. */
     preload(model: Model): Promise<void>;
     /** Apply the host-owned process limit and retire excess idle processes. */

package/dist/service/process-pool.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ModelProcessPool_instances, _ModelProcessPool_createSupervisor, _ModelProcessPool_createScheduler, _ModelProcessPool_loadModel, _ModelProcessPool_onChange, _ModelProcessPool_logger, _ModelProcessPool_slots, _ModelProcessPool_queue, _ModelProcessPool_maxModels, _ModelProcessPool_busy, _ModelProcessPool_dirty, _ModelProcessPool_clock, _ModelProcessPool_makeSlot, _ModelProcessPool_announce, _ModelProcessPool_dispatch, _ModelProcessPool_pass, _ModelProcessPool_slotFor, _ModelProcessPool_nextSlotIndex, _ModelProcessPool_releaseSlot, _ModelProcessPool_trimIdleSlots;
+var _ModelProcessPool_instances, _ModelProcessPool_createSupervisor, _ModelProcessPool_createScheduler, _ModelProcessPool_loadModel, _ModelProcessPool_onChange, _ModelProcessPool_logger, _ModelProcessPool_slots, _ModelProcessPool_queue, _ModelProcessPool_maxModels, _ModelProcessPool_busy, _ModelProcessPool_dirty, _ModelProcessPool_clock, _ModelProcessPool_makeSlot, _ModelProcessPool_loadSlot, _ModelProcessPool_announce, _ModelProcessPool_dispatch, _ModelProcessPool_pass, _ModelProcessPool_slotFor, _ModelProcessPool_nextSlotIndex, _ModelProcessPool_releaseSlot, _ModelProcessPool_trimIdleSlots;
 /**
  * Global admission and eviction boundary for independently hosted models.
  *
@@ -52,6 +52,28 @@ export class ModelProcessPool {
             queueMicrotask(() => void __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_dispatch).call(this));
         });
     }
+    /** Run an exclusive operation with pool-owned model lifecycle controls. */
+    submitOperation(model, run, options) {
+        return this.submit(model, async (supervisor) => {
+            const slot = __classPrivateFieldGet(this, _ModelProcessPool_slots, "f").find((candidate) => candidate.supervisor === supervisor);
+            if (!slot)
+                throw new Error("The scheduled model process is no longer in the pool.");
+            return run({
+                supervisor,
+                start: async (profile) => {
+                    await __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_loadSlot).call(this, slot, model, profile);
+                },
+                stop: async () => {
+                    var _a;
+                    await supervisor.stop();
+                    slot.scheduler.forgetSlots();
+                    slot.reservationBytes = 0;
+                    slot.lastUsedAt = __classPrivateFieldSet(this, _ModelProcessPool_clock, (_a = __classPrivateFieldGet(this, _ModelProcessPool_clock, "f"), ++_a), "f");
+                    __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_announce).call(this);
+                },
+            });
+        }, options);
+    }
     /** Load a model and leave it resident without consuming an inference slot. */
     async preload(model) {
         await this.submit(model, async () => undefined);
@@ -141,18 +163,18 @@ _ModelProcessPool_createSupervisor = new WeakMap(), _ModelProcessPool_createSche
         reservationBytes: 0,
         lastUsedAt: __classPrivateFieldSet(this, _ModelProcessPool_clock, (_a = __classPrivateFieldGet(this, _ModelProcessPool_clock, "f"), ++_a), "f"),
     };
-    slot.scheduler = __classPrivateFieldGet(this, _ModelProcessPool_createScheduler, "f").call(this, supervisor, async (model) => {
-        var _a;
-        const reservedElsewhereBytes = __classPrivateFieldGet(this, _ModelProcessPool_slots, "f").reduce((total, candidate) => (candidate === slot ? total : total + candidate.reservationBytes), 0);
-        slot.reservationBytes = await __classPrivateFieldGet(this, _ModelProcessPool_loadModel, "f").call(this, supervisor, model, reservedElsewhereBytes);
-        slot.assignedModelId = model.id;
-        slot.lastUsedAt = __classPrivateFieldSet(this, _ModelProcessPool_clock, (_a = __classPrivateFieldGet(this, _ModelProcessPool_clock, "f"), ++_a), "f");
-        __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_announce).call(this);
-    }, () => {
+    slot.scheduler = __classPrivateFieldGet(this, _ModelProcessPool_createScheduler, "f").call(this, supervisor, async (model) => __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_loadSlot).call(this, slot, model), () => {
         __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_announce).call(this);
         void __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_dispatch).call(this);
     });
     return slot;
+}, _ModelProcessPool_loadSlot = async function _ModelProcessPool_loadSlot(slot, model, profile) {
+    var _a;
+    const reservedElsewhereBytes = __classPrivateFieldGet(this, _ModelProcessPool_slots, "f").reduce((total, candidate) => (candidate === slot ? total : total + candidate.reservationBytes), 0);
+    slot.reservationBytes = await __classPrivateFieldGet(this, _ModelProcessPool_loadModel, "f").call(this, slot.supervisor, model, reservedElsewhereBytes, profile);
+    slot.assignedModelId = model.id;
+    slot.lastUsedAt = __classPrivateFieldSet(this, _ModelProcessPool_clock, (_a = __classPrivateFieldGet(this, _ModelProcessPool_clock, "f"), ++_a), "f");
+    __classPrivateFieldGet(this, _ModelProcessPool_instances, "m", _ModelProcessPool_announce).call(this);
 }, _ModelProcessPool_announce = function _ModelProcessPool_announce() {
     try {
         __classPrivateFieldGet(this, _ModelProcessPool_onChange, "f")?.call(this);

package/dist/service/router.d.ts

@@ -113,8 +113,10 @@ export declare function buildModelList(supervisor: Supervisor, getCatalog: GetCa
  * Map an OpenAI-compatible effort request onto a model's own chat-template
  * arguments. llama.cpp does not know every model's dialect: Qwen3.8 calls the
  * controls `enable_thinking` and `reasoning_effort`, for example. Only catalog
- * entries that declare these names are rewritten, so generic models and GPT-OSS
- * keep their existing server-native request handling.
+ * entries that declare these names receive a translated request. An arbitrary
+ * GGUF template must never see Otto's generic `reasoning_effort` field: its
+ * accepted values are template-specific, and an incompatible value makes
+ * llama.cpp fail the whole completion with a Jinja exception.
  */
 export declare function applyModelReasoningTemplate(body: Buffer, model: Model): Buffer;
 /**

package/dist/service/router.js

@@ -26,7 +26,11 @@ const MAX_ANALYSIS_BYTES = 2 * 1024 * 1024;
 // Completion bodies are buffered so the scheduler can read `model` and replay
 // them after a possible model switch. Long-context prompts are large but bounded.
 const MAX_REQUEST_BYTES = 64 * 1024 * 1024;
-const COMPLETION_RE = /\/v1\/(messages|chat\/completions)/;
+// llama.cpp accepts both its versioned OpenAI paths and the unversioned
+// aliases. They are the same completion surface to Brain: both must enter the
+// scheduler so generic reasoning_effort is translated before a chat template
+// can render it.
+const COMPLETION_RE = /\/(?:v1\/)?(messages|chat\/completions)(?:[/?]|$)/;
 export class Telemetry {
     constructor(keep = 50) {
         this.keep = keep;
@@ -284,14 +288,14 @@ const reasoningTracker = new ReasoningTracker();
  * Map an OpenAI-compatible effort request onto a model's own chat-template
  * arguments. llama.cpp does not know every model's dialect: Qwen3.8 calls the
  * controls `enable_thinking` and `reasoning_effort`, for example. Only catalog
- * entries that declare these names are rewritten, so generic models and GPT-OSS
- * keep their existing server-native request handling.
+ * entries that declare these names receive a translated request. An arbitrary
+ * GGUF template must never see Otto's generic `reasoning_effort` field: its
+ * accepted values are template-specific, and an incompatible value makes
+ * llama.cpp fail the whole completion with a Jinja exception.
  */
 export function applyModelReasoningTemplate(body, model) {
     const template = model.reasoningTemplate;
     const advertised = model.reasoningEfforts;
-    if (!template || !Array.isArray(advertised))
-        return body;
     let parsed;
     try {
         parsed = JSON.parse(body.toString("utf8"));
@@ -301,26 +305,38 @@ export function applyModelReasoningTemplate(body, model) {
     }
     if (!isRecord(parsed) || typeof parsed.reasoning_effort !== "string")
         return body;
+    const { reasoning_effort: _reasoningEffort, ...withoutReasoningEffort } = parsed;
+    // The Brain owns this generic field. An uncurated model can expose a
+    // reasoning channel without declaring how to control it, so preserve the
+    // template default rather than forwarding a value that can crash rendering.
+    if (!template || !Array.isArray(advertised)) {
+        return Buffer.from(JSON.stringify(withoutReasoningEffort), "utf8");
+    }
     const requested = parsed.reasoning_effort.toLowerCase();
     const knownEfforts = new Set(advertised.map((value) => value.toLowerCase()));
     const isDisabled = requested === "off" || requested === "none";
     const isEnabled = requested === "on" || knownEfforts.has(requested);
-    if (!isDisabled && !isEnabled)
-        return body;
+    // Old chats can retain a formerly valid generic level that this model does
+    // not support. Do not let that stale state turn into a server error.
+    if (!isDisabled && !isEnabled) {
+        return Buffer.from(JSON.stringify(withoutReasoningEffort), "utf8");
+    }
     const suppliedKwargs = parsed.chat_template_kwargs;
     if (suppliedKwargs !== undefined && !isRecord(suppliedKwargs))
         return body;
     const templateKwargs = { ...suppliedKwargs };
     templateKwargs[template.enableThinkingArgument] = !isDisabled;
-    if (knownEfforts.has(requested)) {
+    if (requested !== "on" && knownEfforts.has(requested)) {
         templateKwargs[template.effortArgument] = requested;
     }
     else {
         // The generic On selection means the model's native default, not a stale
-        // explicit effort that happened to be supplied by a previous client.
+        // explicit effort that happened to be supplied by a previous client. It
+        // stays generic even for a model that advertises "on" as its only level:
+        // that answer says the template has a toggle and no named ladder, so
+        // forwarding the word itself is the invalid value this guard exists to stop.
         delete templateKwargs[template.effortArgument];
     }
-    const { reasoning_effort: _reasoningEffort, ...withoutReasoningEffort } = parsed;
     return Buffer.from(JSON.stringify({ ...withoutReasoningEffort, chat_template_kwargs: templateKwargs }), "utf8");
 }
 /**
@@ -588,7 +604,7 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
     });
 }
 export function completionShape(url) {
-    return /\/v1\/messages/.test(url ?? "") ? "anthropic" : "openai";
+    return /\/(?:v1\/)?messages(?:[/?]|$)/.test(url ?? "") ? "anthropic" : "openai";
 }
 /** One text block, as both API shapes spell it inside a structured content array. */
 function textBlock(text) {
@@ -995,6 +1011,22 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
         // Otto's GUI consume, so the two never drift. Status is live; config and
         // evals are point-in-time reads the daemon proxies to its settings UI.
         const path = (req.url || "").split("?")[0];
+        // `/health` is the SERVICE's liveness, not the model's, and it is answered
+        // here rather than proxied to llama-server. This host is multi-model and
+        // starts unloaded whenever no default is configured ("Automatic"), so the
+        // proxy path below would answer 503 for a perfectly healthy service with an
+        // empty slot - which is exactly what the daemon's startup probe and `otto
+        // brain status` read as "the service failed to start". Model readiness is
+        // reported by `/__host/status` (and its event stream), which is where a
+        // caller that actually needs it must look.
+        if (path === "/health") {
+            sendJson(res, {
+                status: "ok",
+                state: supervisor.state,
+                model: supervisor.model?.displayName ?? null,
+            });
+            return;
+        }
         if (path === "/__host/status") {
             // Resources cost an `nvidia-smi` spawn, so they are opt-in: the daemon
             // reads this route far more often than any UI does, and must not pay for
@@ -1099,7 +1131,7 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
                     outHeaders[name] = value;
             }
             res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
-            const isCompletion = /\/v1\/(messages|chat\/completions)/.test(req.url || "");
+            const isCompletion = COMPLETION_RE.test(req.url || "");
             const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
             if (!isCompletion || isStream) {
                 // Streaming: pass through untouched, but note whether any content

package/dist/service/serve.js

@@ -16,7 +16,7 @@ import https from "node:https";
 import { getCalibrationForBudget, forModel, loadPersistedConfig, loadProfilesStore, put, putCalibration, saveBrainConfig, saveProfilesStore, } from "../config/index.js";
 import { resolveBrainPaths } from "../config/paths.js";
 import { query as queryGpu } from "../gpu.js";
-import { managedModelsDir, pickAutoModel, pickModel, scanModels } from "../models/index.js";
+import { managedModelsDir, pickModel, scanModels } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { resolveRuntime } from "../runtime/index.js";
 import * as vram from "../vram.js";
@@ -172,9 +172,9 @@ class ServiceJobRunner {
             job.queuePosition = this.scheduler.stats().queued + 1;
             job.message = `Queued for ${model.displayName}`;
             void this.scheduler
-                .submit(model, (supervisor) => controller.signal.aborted
+                .submitOperation(model, (process) => controller.signal.aborted
                 ? Promise.reject(new Error("Operation canceled."))
-                : this.runResidentJob(supervisor, kind, model.id, {
+                : this.runResidentJob(process, kind, model.id, {
                     message: (value) => {
                         if (job.status === "running")
                             job.message = value.slice(-1000);
@@ -450,15 +450,18 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         catalog = scanModels(config, env);
         return catalog;
     };
-    const needle = modelNeedle ?? config.defaultModel ?? store.lastModelId ?? undefined;
+    // A configured default is the only implicit startup load. Keeping this null
+    // deliberately starts the host unloaded; an incoming request selects and
+    // loads its model on demand. `lastModelId` is history, never a hidden default.
+    const needle = modelNeedle ?? config.defaultModel ?? undefined;
     let model = null;
-    if (catalog.length > 0) {
+    if (catalog.length > 0 && needle) {
         try {
-            model = needle ? pickModel(catalog, needle) : pickAutoModel(catalog);
+            model = pickModel(catalog, needle);
         }
         catch (error) {
-            // A removed default or last-used model must not take the management
-            // service down. An explicit CLI selection remains an actionable error.
+            // A removed configured default must not take the management service down.
+            // An explicit CLI selection remains an actionable error.
             if (modelNeedle)
                 throw error;
             log("server", `note: ${error instanceof Error ? error.message : "configured model is unavailable"}`);
@@ -496,7 +499,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     });
     supervisor.on("log", (line) => log("server", line));
     supervisor.on("crashed", (error) => log("model", `FATAL ${error}`));
-    const loadModelInto = async (resident, target, reservedElsewhereBytes) => {
+    const loadModelInto = async (resident, target, reservedElsewhereBytes, exactProfile) => {
         // A runtime can be installed from the Library tab after this service starts.
         // Resolve it at load time so the user does not have to restart the brain.
         resident.runtime = resolveRuntime(config, env);
@@ -504,26 +507,47 @@ export async function startService({ config, modelNeedle, env = process.env, onL
             throw new Error("no llama.cpp runtime available; install one from the Library tab");
         }
         const gpuInfo = await queryGpu();
-        let fitProfile = forModel(store, target, config.defaults);
+        let fitProfile = exactProfile ?? forModel(store, target, config.defaults);
         let reservationBytes = 0;
         if (gpuInfo) {
-            const fit = vram.fitToBudget({
-                model: target,
-                profile: fitProfile,
-                calibration: getCalibrationForBudget(store, target, fitProfile),
-                // Every resident process keeps its complete budget reserved. Fit this
-                // process against the capacity left after those independent allocations.
-                totalVramBytes: Math.max(0, gpuInfo.totalBytes - reservedElsewhereBytes),
-            });
-            if (!fit.adjusted && !fit.budget.fits)
-                throw new Error(fit.reason ?? "does not fit");
-            fitProfile = fit.profile;
-            reservationBytes = fit.budget.totalBytes;
+            const totalVramBytes = Math.max(0, gpuInfo.totalBytes - reservedElsewhereBytes);
+            const calibration = getCalibrationForBudget(store, target, fitProfile);
+            if (exactProfile) {
+                const exactBudget = vram.budget({
+                    model: target,
+                    profile: fitProfile,
+                    calibration,
+                    totalVramBytes,
+                });
+                if (!exactBudget.fits) {
+                    throw new Error("the operation profile does not fit beside the other resident models");
+                }
+                reservationBytes = exactBudget.totalBytes;
+            }
+            else {
+                const fit = vram.fitToBudget({
+                    model: target,
+                    profile: fitProfile,
+                    calibration,
+                    // Every resident process keeps its complete budget reserved. Fit this
+                    // process against the capacity left after those independent allocations.
+                    totalVramBytes,
+                });
+                if (!fit.adjusted && !fit.budget.fits)
+                    throw new Error(fit.reason ?? "does not fit");
+                fitProfile = fit.profile;
+                reservationBytes = fit.budget.totalBytes;
+            }
         }
         await resident.start(target, fitProfile);
-        delete store.pendingReloadModelIds[target.id];
-        store.lastModelId = target.id;
-        saveProfilesStore(store, paths);
+        // Temporary calibration/sweep profiles are not a user-requested reload of
+        // the saved hosting profile. Only an ordinary pool load clears that badge
+        // and advances the durable last-model selection.
+        if (!exactProfile) {
+            delete store.pendingReloadModelIds[target.id];
+            store.lastModelId = target.id;
+            saveProfilesStore(store, paths);
+        }
         return reservationBytes;
     };
     let processPool = null;
@@ -604,7 +628,8 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     // /__host/events. One instance, so `capabilities.events` and the stream can
     // never disagree about whether this brain publishes.
     const statusEvents = new BrainStatusPublisher();
-    const runResidentJob = async (supervisor, kind, target, update, signal) => {
+    const runResidentJob = async (process, kind, target, update, signal) => {
+        const { supervisor } = process;
         const ensureActive = () => {
             if (signal.aborted)
                 throw new Error("Operation canceled.");
@@ -627,6 +652,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
                 model: targetModel,
                 profile,
                 supervisor,
+                lifecycle: process,
                 onProgress: (event) => {
                     ensureActive();
                     const message = event.phase === "loading"
@@ -659,6 +685,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
                 model: targetModel,
                 profile,
                 supervisor,
+                lifecycle: process,
                 onProgress: (event) => {
                     ensureActive();
                     const message = event.phase === "loading"
@@ -900,9 +927,15 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     else if (!runtime) {
         log("server", "ready: no llama.cpp runtime installed; use the Library tab to download one");
     }
-    else {
+    else if (catalog.length === 0) {
         log("server", "ready: no model installed; use the Library tab to download one");
     }
+    else {
+        // The "Automatic" default: nothing is preloaded on purpose, and the first
+        // completion picks and loads its own model. Say so, or the empty slot reads
+        // as a failure to anyone tailing the log.
+        log("server", "ready: no startup model configured; a request will load one on demand");
+    }
     writePidFile({
         pid: process.pid,
         host: bindHost,

package/dist/service/supervisor.d.ts

@@ -1,5 +1,6 @@
 import { type ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { type ModelServerLaunch, type ModelServerRuntimeDriver } from "../runtime/index.js";
 import { type BrainPaths } from "../config/paths.js";
 import type { Model, Runtime } from "../types.js";
 import type { Profile, ProfilesStore } from "../config/schema.js";
@@ -18,6 +19,8 @@ export declare const DEFAULT_INTERNAL_PORT = 20800;
 export type SupervisorState = "stopped" | "starting" | "ready" | "failed" | "stopping";
 export interface SupervisorOptions {
     runtime: Runtime | null;
+    /** Native launch/introspection mechanics; lifecycle policy stays in this host. */
+    driver?: ModelServerRuntimeDriver;
     internalPort?: number;
     host?: string;
     logVerbosity?: number;
@@ -44,7 +47,7 @@ export interface SupervisorStatus {
     runtime: string;
 }
 /**
- * Owns the llama-server child process.
+ * Owns the model-server child process.
  *
  * The server always listens on a private port; `router.js` fronts it on a
  * stable one so switching models never asks a client to reconnect elsewhere.
@@ -58,6 +61,7 @@ export declare class Supervisor extends EventEmitter {
     readyTimeoutMs: number;
     paths: BrainPaths;
     getProfilesStore: () => ProfilesStore;
+    driver: ModelServerRuntimeDriver;
     state: SupervisorState;
     child: ChildProcess | null;
     model: Model | null;
@@ -75,10 +79,11 @@ export declare class Supervisor extends EventEmitter {
      * shell line is for reading, not for re-parsing.
      */
     args: string[] | null;
-    constructor({ runtime, internalPort, host, logVerbosity, readyTimeoutMs, paths, getProfilesStore, }: SupervisorOptions);
+    launch: ModelServerLaunch | null;
+    constructor({ runtime, driver, internalPort, host, logVerbosity, readyTimeoutMs, paths, getProfilesStore, }: SupervisorOptions);
     get upstreamBase(): string;
     /**
-     * Add a host-operation event to the same in-process tail as llama-server output.
+     * Add a host-operation event to the same in-process tail as model-server output.
      *
      * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
      * than creating invisible sidecar servers. Their lifecycle markers belong in
@@ -89,9 +94,9 @@ export declare class Supervisor extends EventEmitter {
     /**
      * Start (or restart) the server for a model + profile.
      *
-     * This is the sole llama-server launch boundary, so it materializes the
-     * selected hosting profile here. Keeping it beside `buildArgs()` makes the
-     * Jinja template and router-visible system addendum mandatory for every
+     * This is the sole model-server launch boundary, so it materializes the
+     * selected hosting profile here. Keeping it at this one driver call makes
+     * the Jinja template and router-visible system addendum mandatory for every
      * caller, including future maintenance operations that start a sidecar.
      */
     start(model: Model, profile: Profile): Promise<this>;

package/dist/service/supervisor.js

@@ -5,17 +5,15 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _Supervisor_instances, _Supervisor_setState, _Supervisor_log, _Supervisor_health;
 import http from "node:http";
-import path from "node:path";
-import { mkdirSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { buildArgs, buildEnv, formatCommand } from "../runtime/index.js";
+import { llamaCppRuntimeDriver, } from "../runtime/index.js";
 import { resolveHostingProfileForLaunch } from "../config/hosting-profiles.js";
 import { getCalibrationForBudget } from "../config/profiles.js";
 import { resolveBrainPaths } from "../config/paths.js";
 import { loadProfilesStore } from "../config/store.js";
 import { usedBytes } from "../gpu.js";
-import { formatBrainLog, formatLlamaServerLog } from "./log-format.js";
+import { formatBrainLog } from "./log-format.js";
 const LOG_LINES_KEPT = 10000;
 /**
  * Default loopback port for the private llama-server child. Deliberately clear
@@ -29,16 +27,17 @@ const LOG_LINES_KEPT = 10000;
  */
 export const DEFAULT_INTERNAL_PORT = 20800;
 /**
- * Owns the llama-server child process.
+ * Owns the model-server child process.
  *
  * The server always listens on a private port; `router.js` fronts it on a
  * stable one so switching models never asks a client to reconnect elsewhere.
  */
 export class Supervisor extends EventEmitter {
-    constructor({ runtime, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", logVerbosity = 3, readyTimeoutMs = 300000, paths = resolveBrainPaths(), getProfilesStore = loadProfilesStore, }) {
+    constructor({ runtime, driver = llamaCppRuntimeDriver, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", logVerbosity = 3, readyTimeoutMs = 300000, paths = resolveBrainPaths(), getProfilesStore = loadProfilesStore, }) {
         super();
         _Supervisor_instances.add(this);
         this.runtime = runtime;
+        this.driver = driver;
         this.internalPort = internalPort;
         this.host = host;
         this.logVerbosity = logVerbosity;
@@ -57,12 +56,13 @@ export class Supervisor extends EventEmitter {
         this.vramBaselineBytes = null;
         this.command = null;
         this.args = null;
+        this.launch = null;
     }
     get upstreamBase() {
         return `http://${this.host}:${this.internalPort}`;
     }
     /**
-     * Add a host-operation event to the same in-process tail as llama-server output.
+     * Add a host-operation event to the same in-process tail as model-server output.
      *
      * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
      * than creating invisible sidecar servers. Their lifecycle markers belong in
@@ -75,61 +75,53 @@ export class Supervisor extends EventEmitter {
     /**
      * Start (or restart) the server for a model + profile.
      *
-     * This is the sole llama-server launch boundary, so it materializes the
-     * selected hosting profile here. Keeping it beside `buildArgs()` makes the
-     * Jinja template and router-visible system addendum mandatory for every
+     * This is the sole model-server launch boundary, so it materializes the
+     * selected hosting profile here. Keeping it at this one driver call makes
+     * the Jinja template and router-visible system addendum mandatory for every
      * caller, including future maintenance operations that start a sidecar.
      */
     async start(model, profile) {
         await this.stop();
         if (!this.runtime) {
-            this.lastError = "no llama.cpp runtime available";
+            this.lastError = `no ${this.driver.displayName} runtime available`;
             __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "failed", this.lastError);
             throw new Error(this.lastError);
         }
         const runtime = this.runtime;
-        // The engine's slot save/erase directory, under the brain's home so it
-        // survives across model relaunches (the dir is persistent; the engine only
-        // ever uses it for the `action=erase` the scheduler issues on a handoff,
-        // which never writes a file). Created before the args are built because
-        // llama.cpp validates it exists at launch and throws otherwise.
-        const slotSavePath = path.join(this.paths.root, "slot-saves");
-        try {
-            mkdirSync(slotSavePath, { recursive: true });
-        }
-        catch {
-            /* the engine then starts without slot actions - the pre-fix behavior */
-        }
         const launchProfile = resolveHostingProfileForLaunch(this.paths, this.getProfilesStore(), profile, model.family);
         this.model = model;
         this.profile = launchProfile;
         this.lastError = null;
         this.vramBaselineBytes = await usedBytes();
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "starting");
-        const args = buildArgs({ ...launchProfile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, {
-            port: this.internalPort,
+        const launch = this.driver.createLaunch({
+            runtime,
+            model,
+            profile: launchProfile,
+            // The prompt-cache budget is derived from measured KV bytes/token, so the
+            // launch boundary is where it has to be resolved - nothing downstream of
+            // here can reach the calibration store.
+            calibration: getCalibrationForBudget(this.getProfilesStore(), model, launchProfile),
+            paths: this.paths,
             host: this.host,
+            port: this.internalPort,
             logVerbosity: this.logVerbosity,
-            slotSavePath,
-        }, model, 
-        // The prompt-cache budget is derived from measured KV bytes/token, so the
-        // launch boundary is where it has to be resolved - nothing downstream of
-        // here can reach the calibration store.
-        getCalibrationForBudget(this.getProfilesStore(), model, launchProfile));
-        this.args = args;
-        this.command = formatCommand(runtime, args);
+        });
+        this.launch = launch;
+        this.args = launch.args;
+        this.command = launch.command;
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, formatBrainLog("model", `launching: ${this.command}`));
         const started = Date.now();
-        this.child = spawn(runtime.exe, args, {
-            cwd: runtime.dir,
-            env: buildEnv(runtime),
+        this.child = spawn(launch.executable, launch.args, {
+            cwd: launch.cwd,
+            env: launch.env,
             windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
         });
         const onChunk = (chunk) => {
             for (const line of String(chunk).split(/\r?\n/)) {
                 if (line.trim())
-                    __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, formatLlamaServerLog(line.trim()));
+                    __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, launch.formatLogLine(line.trim()));
             }
         };
         this.child.stdout?.on("data", onChunk);
@@ -143,15 +135,13 @@ export class Supervisor extends EventEmitter {
                 return;
             }
             exitedEarly = { code, signal };
-            // 3221225781 == 0xC0000135 STATUS_DLL_NOT_FOUND: the vendor DLL trap.
-            const hint = code === 3221225781 ? " (missing runtime DLLs - the vendor directory was not on PATH)" : "";
-            this.lastError = `llama-server exited with code ${code}${signal ? ` signal ${signal}` : ""}${hint}`;
+            this.lastError = this.driver.describeProcessExit({ code, signal });
             __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "failed", this.lastError);
             if (wasReady)
                 this.emit("crashed", this.lastError);
         });
         this.child.once("error", (error) => {
-            this.lastError = `could not launch llama-server: ${error.message}`;
+            this.lastError = this.driver.describeLaunchError(error);
             __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "failed", this.lastError);
         });
         // Poll /health until the model finishes loading.
@@ -164,7 +154,7 @@ export class Supervisor extends EventEmitter {
             const used = await usedBytes();
             if (used && used > peakVram)
                 peakVram = used;
-            const health = await __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_health).call(this);
+            const health = await __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_health).call(this, launch.readinessPath);
             if (health) {
                 this.loadSeconds = (Date.now() - started) / 1000;
                 this.startedAt = new Date();
@@ -185,8 +175,11 @@ export class Supervisor extends EventEmitter {
     }
     /** Fetch /props from the running server (modalities, template caps, defaults). */
     props() {
+        const pathname = this.launch?.propertiesPath;
+        if (!pathname)
+            return Promise.resolve(null);
         return new Promise((resolve) => {
-            const req = http.get({ host: this.host, port: this.internalPort, path: "/props", timeout: 5000 }, (res) => {
+            const req = http.get({ host: this.host, port: this.internalPort, path: pathname, timeout: 5000 }, (res) => {
                 let body = "";
                 res.on("data", (c) => (body += c));
                 res.on("end", () => {
@@ -263,9 +256,9 @@ _Supervisor_instances = new WeakSet(), _Supervisor_setState = function _Supervis
     if (this.logLines.length > LOG_LINES_KEPT)
         this.logLines.shift();
     this.emit("log", line);
-}, _Supervisor_health = function _Supervisor_health() {
+}, _Supervisor_health = function _Supervisor_health(pathname) {
     return new Promise((resolve) => {
-        const req = http.get({ host: this.host, port: this.internalPort, path: "/health", timeout: 2500 }, (res) => {
+        const req = http.get({ host: this.host, port: this.internalPort, path: pathname, timeout: 2500 }, (res) => {
             res.resume();
             resolve(res.statusCode === 200);
         });

package/dist/types.d.ts

@@ -23,6 +23,12 @@ export interface ModelMetadata {
     reasoning?: boolean;
     /** Native template key detected from `preserve_thinking` or `preserve_reasoning`. */
     reasoningPreservationArgument?: string;
+    /** Template argument that switches the thinking channel on or off. */
+    reasoningToggleArgument?: string;
+    /** Template argument that carries a graduated effort level. */
+    reasoningEffortArgument?: string;
+    /** Effort levels the chat template names itself, when it validates a set. */
+    reasoningEffortValues?: string[];
     [key: string]: unknown;
 }
 export interface ModelFeatures {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/brain",
-  "version": "0.8.17",
+  "version": "0.8.19",
   "description": "Otto Brain - self-contained host for local GGUF models, with measured VRAM budgeting and reasoning-budget control",
   "license": "AGPL-3.0-or-later",
   "bin": {