@otto-code/brain 0.8.7 → 0.8.9

package/dist/service/router.js

@@ -149,6 +149,7 @@ export function describeModel(model, options = {}) {
         // OpenAI-compatible clients send `id`; Otto uses `name` for presentation.
         id: model.id,
         name: model.displayName,
+        ...(model.family ? { family: model.family } : {}),
         object: "model",
         created: Math.floor((createdAt ? createdAt.getTime() : Date.now()) / 1000),
         owned_by: model.publisher || "local",
@@ -159,7 +160,13 @@ export function describeModel(model, options = {}) {
         compatibility_type: "gguf",
         quantization: model.quant || null,
         state,
-        max_context_length: md.contextLength ?? null,
+        // The GGUF header remains the native limit, but an actively loaded YaRN
+        // profile intentionally extends the server's usable maximum. Publish that
+        // effective ceiling so OpenAI-compatible clients do not reject a context
+        // that this very llama-server instance has been configured to accept.
+        max_context_length: typeof md.contextLength === "number"
+            ? md.contextLength * (profile?.contextMultiplier ?? 1)
+            : null,
         // GGUF template detection is deliberately conservative. A false result
         // means "not detected", not proof that a catalog-marked reasoner is not
         // one, so preserve the catalog's positive capability metadata.
@@ -290,13 +297,17 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, r
                 resolve();
             }
         };
+        // Injected here, not at queue time: the scheduler may switch models between
+        // buffering and dispatch, and the addendum belongs to whichever model ends
+        // up resident, which is the one `supervisor.profile` now describes.
+        const outbound = injectSystemAddendum(body, supervisor.profile?.chatSystemAddendum ?? null, completionShape(req.url));
         const headers = {};
         for (const [name, value] of Object.entries(req.headers)) {
             if (!HOP_BY_HOP.has(name.toLowerCase()))
                 headers[name] = value;
         }
         headers.host = `${supervisor.host}:${supervisor.internalPort}`;
-        headers["content-length"] = Buffer.byteLength(body);
+        headers["content-length"] = Buffer.byteLength(outbound);
         const started = Date.now();
         const upstream = http.request({
             host: supervisor.host,
@@ -406,9 +417,78 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, r
         // being dispatched to llama-server and is waiting for prompt processing or
         // its first output delta.
         reasoning?.begin(streamId);
-        upstream.end(body);
+        upstream.end(outbound);
     });
 }
+export function completionShape(url) {
+    return /\/v1\/messages/.test(url ?? "") ? "anthropic" : "openai";
+}
+/** One text block, as both API shapes spell it inside a structured content array. */
+function textBlock(text) {
+    return { type: "text", text };
+}
+/**
+ * Append the active hosting profile's system-prompt addendum to a buffered
+ * completion body.
+ *
+ * Appending rather than prepending or replacing is the whole point: the agent's
+ * own system prompt still leads, and the profile's instructions are read last.
+ * A body this cannot understand is forwarded untouched - a malformed or
+ * unfamiliar request must still reach llama-server and get llama-server's own
+ * error, not a 400 invented here.
+ *
+ * Cost is one extra parse/serialize per request, paid only by models whose
+ * profile actually sets an addendum.
+ */
+export function injectSystemAddendum(body, addendum, shape) {
+    if (!addendum)
+        return body;
+    let parsed;
+    try {
+        parsed = JSON.parse(body.toString("utf8"));
+    }
+    catch {
+        return body;
+    }
+    if (!isRecord(parsed))
+        return body;
+    if (shape === "anthropic") {
+        // Anthropic carries the system turn beside `messages`, never inside it.
+        const system = parsed.system;
+        if (system === undefined || system === null || system === "")
+            parsed.system = addendum;
+        else if (typeof system === "string")
+            parsed.system = `${system}\n\n${addendum}`;
+        else if (Array.isArray(system))
+            parsed.system = [...system, textBlock(addendum)];
+        else
+            return body;
+        return Buffer.from(JSON.stringify(parsed), "utf8");
+    }
+    const messages = parsed.messages;
+    if (!Array.isArray(messages))
+        return body;
+    // `developer` is the newer OpenAI spelling of the same turn; either one is
+    // the message this addendum belongs on.
+    const index = messages.findIndex((message) => isRecord(message) && (message.role === "system" || message.role === "developer"));
+    if (index === -1) {
+        parsed.messages = [{ role: "system", content: addendum }, ...messages];
+        return Buffer.from(JSON.stringify(parsed), "utf8");
+    }
+    const existing = messages[index];
+    const content = existing.content;
+    let merged;
+    if (content === undefined || content === null || content === "")
+        merged = addendum;
+    else if (typeof content === "string")
+        merged = `${content}\n\n${addendum}`;
+    else if (Array.isArray(content))
+        merged = [...content, textBlock(addendum)];
+    else
+        return body;
+    parsed.messages = messages.map((message, at) => at === index ? { ...existing, content: merged } : message);
+    return Buffer.from(JSON.stringify(parsed), "utf8");
+}
 /**
  * Pure model-admission decision, factored out of the router so it is unit
  * testable. `pinned` is the single model a locked host serves; `resolved` is the
@@ -497,7 +577,12 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
 // window - the cheap time-based trigger.
 const RANKING_TTL_MS = 60000;
 export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, statusEvents = null, }) {
-    const agent = new http.Agent({ keepAlive: true, maxSockets: 32 });
+    // llama-server may close an idle response socket while this scheduler holds
+    // the next request in queue. A reused keep-alive socket then fails as
+    // ECONNRESET ("socket hang up") before the queued request reaches inference.
+    // Inference time dwarfs localhost connection setup, so isolate each request
+    // instead of letting a second client inherit a stale upstream connection.
+    const agent = new http.Agent({ keepAlive: false, maxSockets: 32 });
     const scheduler = loadModel
         ? new Scheduler({
             supervisor,

package/dist/service/serve.js

@@ -13,7 +13,7 @@ import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import http from "node:http";
 import https from "node:https";
-import { getCalibration, forModel, loadPersistedConfig, loadProfilesStore, saveBrainConfig, saveProfilesStore, } from "../config/index.js";
+import { getCalibration, 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";
@@ -22,8 +22,13 @@ import { resolveRuntime } from "../runtime/index.js";
 import * as vram from "../vram.js";
 import { resolveVersion } from "../version.js";
 import * as results from "../ops/results.js";
+import * as archive from "../ops/archive.js";
+import { calibrate } from "../ops/calibrate.js";
+import { sweep } from "../ops/sweep.js";
+import * as bench from "../bench/index.js";
 import { createCpuSampler, sample as sampleSystem } from "../sysmon.js";
 import { createHostApi } from "./host-api.js";
+import { errorMessage } from "./http-util.js";
 import { createRouter, Telemetry } from "./router.js";
 import { BrainStatusPublisher } from "./status-events.js";
 import { Supervisor } from "./supervisor.js";
@@ -57,13 +62,10 @@ function collectEvals() {
     }
 }
 const REMOTE_JOB_RETENTION_MS = 5 * 60000;
-/**
- * Runs a benchmark as a child of the brain service. This is intentionally here
- * rather than in the connecting daemon: its process, model store, results
- * directory and GPU all belong to the host that is being benchmarked.
- */
 class ServiceJobRunner {
-    constructor() {
+    constructor(onPullCompleted, runResidentJob) {
+        this.onPullCompleted = onPullCompleted;
+        this.runResidentJob = runResidentJob;
         this.jobs = new Map();
     }
     start(kind, target, args) {
@@ -86,7 +88,26 @@ class ServiceJobRunner {
             startedAt: new Date().toISOString(),
             finishedAt: null,
             child: null,
+            controller: null,
         };
+        this.jobs.set(job.id, job);
+        if (kind === "calibrate" || kind === "sweep" || kind === "bench") {
+            const controller = new AbortController();
+            job.controller = controller;
+            void this.runResidentJob(kind, target, {
+                message: (value) => {
+                    if (job.status === "running")
+                        job.message = value.slice(-1000);
+                },
+                percent: (value) => {
+                    if (job.status === "running")
+                        job.percent = value;
+                },
+            }, controller.signal)
+                .then(() => this.finish(job, "succeeded", null))
+                .catch((error) => this.finish(job, controller.signal.aborted ? "canceled" : "failed", errorMessage(error)));
+            return this.publicJob(job);
+        }
         // The service is launched by the same CLI entry point as `otto-brain bench`.
         // Reusing that entry point keeps its config/path resolution on this host.
         const entry = process.argv[1];
@@ -99,18 +120,25 @@ class ServiceJobRunner {
             windowsHide: true,
         });
         job.child = child;
-        this.jobs.set(job.id, job);
         child.stderr?.setEncoding("utf8");
-        child.stderr?.on("data", (chunk) => {
-            const last = chunk.trim().split(/\r?\n/).at(-1)?.trim();
-            if (last)
-                job.message = last.slice(-1000);
-        });
+        child.stderr?.on("data", (chunk) => this.ingestOutput(job, chunk));
         child.once("error", (error) => this.finish(job, "failed", error.message));
         child.once("close", (code) => {
             if (job.status !== "running")
                 return;
-            this.finish(job, code === 0 ? "succeeded" : "failed", code === 0 ? null : `Exited with code ${code}.`);
+            if (code === 0 && kind === "pull") {
+                try {
+                    // Downloads happen in a child process, but inventory is served from
+                    // this process's in-memory scan. Reconcile before reporting success
+                    // so a newly downloaded bundle component is immediately available.
+                    this.onPullCompleted();
+                }
+                catch (error) {
+                    this.finish(job, "failed", `Downloaded files, but could not refresh inventory: ${errorMessage(error)}`);
+                    return;
+                }
+            }
+            this.finish(job, code === 0 ? "succeeded" : "failed", code === 0 ? null : (job.message ?? `Exited with code ${code}.`));
         });
         return this.publicJob(job);
     }
@@ -156,8 +184,13 @@ class ServiceJobRunner {
     }
     async cancel(jobId) {
         const job = this.jobs.get(jobId);
-        if (!job || job.status !== "running" || !job.child)
+        if (!job || job.status !== "running")
+            return this.list();
+        if (!job.child) {
+            job.controller?.abort();
+            this.finish(job, "canceled", "Canceled.");
             return this.list();
+        }
         const child = job.child;
         if (process.platform === "win32" && child.pid) {
             await new Promise((resolve) => execFile("taskkill", ["/pid", String(child.pid), "/t", "/f"], () => resolve()));
@@ -168,15 +201,32 @@ class ServiceJobRunner {
         this.finish(job, "canceled", "Canceled.");
         return this.list();
     }
+    ingestOutput(job, chunk) {
+        for (const line of chunk
+            .split(/[\r\n]+/u)
+            .map((value) => value.trim())
+            .filter(Boolean)) {
+            const progress = /(\d{1,3})\s*%/u.exec(line);
+            if (progress)
+                job.percent = Math.max(0, Math.min(100, Number(progress[1])));
+            // The final JSON result is not a useful status label. Keep progress and
+            // actionable text instead, so a failed bundle pull tells the user why.
+            if (line !== "[" && !/^[\]{}",]+$/u.test(line))
+                job.message = line.slice(-1000);
+        }
+    }
     finish(job, status, error) {
         if (job.status !== "running")
             return;
         job.child = null;
+        job.controller = null;
         job.status = status;
         job.error = error;
         job.finishedAt = new Date().toISOString();
+        if (status === "succeeded")
+            job.percent = 100;
     }
-    publicJob({ child: _child, ...job }) {
+    publicJob({ child: _child, controller: _controller, ...job }) {
         return job;
     }
 }
@@ -266,6 +316,10 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     // Not const: deleting a model through the management API re-scans and replaces
     // this, and every reader goes through a getter so nobody holds a stale array.
     let catalog = scanModels(config, env);
+    const rescanCatalog = () => {
+        catalog = scanModels(config, env);
+        return catalog;
+    };
     const needle = modelNeedle ?? config.defaultModel ?? store.lastModelId ?? undefined;
     let model = null;
     if (catalog.length > 0) {
@@ -304,7 +358,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         }
     }
     const telemetry = new Telemetry();
-    const supervisor = new Supervisor({ runtime });
+    const supervisor = new Supervisor({ runtime, paths, getProfilesStore: () => store });
     supervisor.on("log", (line) => {
         runLog.write(line);
         if (/error|failed|warn/i.test(line))
@@ -337,6 +391,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
             fitProfile = fit.profile;
         }
         await supervisor.start(target, fitProfile);
+        delete store.pendingReloadModelIds[target.id];
         store.lastModelId = target.id;
         saveProfilesStore(store, paths);
     };
@@ -389,17 +444,160 @@ 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 jobs = new ServiceJobRunner();
+    const runResidentJob = async (kind, target, update, signal) => {
+        const ensureActive = () => {
+            if (signal.aborted)
+                throw new Error("Operation canceled.");
+        };
+        const modelId = target ?? supervisor.model?.id ?? store.lastModelId ?? null;
+        const targetModel = modelId
+            ? catalog.find((candidate) => candidate.id === modelId || candidate.displayName === modelId)
+            : null;
+        if (!targetModel)
+            throw new Error("No installed model is available for this operation.");
+        const restoreModel = supervisor.model;
+        const restoreProfile = supervisor.profile;
+        const restore = async () => {
+            if (restoreModel && restoreProfile && !signal.aborted) {
+                await supervisor.start(restoreModel, restoreProfile, { preserveLogs: true });
+            }
+        };
+        if (kind === "calibrate") {
+            const runtime = supervisor.runtime ?? resolveRuntime(config, env);
+            if (!runtime)
+                throw new Error("no llama.cpp runtime available; install one from the Library tab");
+            const profile = forModel(store, targetModel, config.defaults);
+            update.message(`Calibrating ${targetModel.displayName}`);
+            supervisor.recordLog(`operation calibrate: ${targetModel.displayName}`);
+            try {
+                const measurement = await calibrate({
+                    runtime,
+                    model: targetModel,
+                    profile,
+                    supervisor,
+                    onProgress: (event) => {
+                        ensureActive();
+                        const message = event.phase === "loading"
+                            ? `Calibrating ${event.contextSize.toLocaleString()} context`
+                            : event.phase === "measured"
+                                ? `Measured ${event.contextSize.toLocaleString()} context`
+                                : (event.reason ??
+                                    event.error ??
+                                    `Skipped ${event.contextSize.toLocaleString()} context`);
+                        update.message(message);
+                        supervisor.recordLog(`operation calibrate: ${message}`);
+                    },
+                });
+                ensureActive();
+                putCalibration(store, targetModel, profile, measurement);
+                saveProfilesStore(store, paths);
+                update.percent(100);
+                supervisor.recordLog(`operation calibrate: saved measurement for ${targetModel.displayName}`);
+            }
+            finally {
+                await restore();
+            }
+            return;
+        }
+        if (kind === "sweep") {
+            const runtime = supervisor.runtime ?? resolveRuntime(config, env);
+            if (!runtime)
+                throw new Error("no llama.cpp runtime available; install one from the Library tab");
+            const profile = forModel(store, targetModel, config.defaults);
+            update.message(`Sweeping ${targetModel.displayName}`);
+            supervisor.recordLog(`operation sweep: ${targetModel.displayName}`);
+            try {
+                const report = await sweep({
+                    runtime,
+                    model: targetModel,
+                    profile,
+                    supervisor,
+                    onProgress: (event) => {
+                        ensureActive();
+                        const message = event.phase === "loading"
+                            ? `Budget ${event.budget}: loading`
+                            : event.phase === "generating"
+                                ? `Budget ${event.budget}: generating`
+                                : event.phase === "done"
+                                    ? `Budget ${event.budget}: complete`
+                                    : `Budget ${event.budget}: ${event.error ?? "failed"}`;
+                        update.message(message);
+                        supervisor.recordLog(`operation sweep: ${message}`);
+                    },
+                });
+                ensureActive();
+                if (report.recommended !== null) {
+                    profile.reasoningBudget = report.recommended;
+                    put(store, targetModel, profile);
+                    saveProfilesStore(store, paths);
+                    supervisor.recordLog(`operation sweep: saved budget ${report.recommended}`);
+                }
+                update.percent(100);
+            }
+            finally {
+                await restore();
+            }
+            return;
+        }
+        update.message(`Benchmarking ${targetModel.displayName}`);
+        supervisor.recordLog(`operation benchmark: ${targetModel.displayName}`);
+        await loadModel(targetModel);
+        ensureActive();
+        supervisor.recordLog(`operation benchmark: resident model ready`);
+        const profile = supervisor.profile ?? forModel(store, targetModel, config.defaults);
+        const gpuInfo = await queryGpu();
+        const calibration = getCalibration(store, targetModel, profile);
+        const fit = gpuInfo
+            ? vram.fitToBudget({
+                model: targetModel,
+                profile,
+                calibration,
+                totalVramBytes: gpuInfo.totalBytes,
+            })
+            : null;
+        const archiveId = archive.runId(targetModel);
+        const report = await bench.runSuite({
+            host: supervisor.host,
+            port: supervisor.internalPort,
+            concurrency: 3,
+            reasoningBudget: profile.reasoningBudget ?? null,
+            contextWindow: profile.contextSize ?? null,
+            archiveId,
+            onProgress: (event) => {
+                ensureActive();
+                const message = event.title
+                    ? `${event.title}: ${event.phase}`
+                    : (event.summary ?? event.phase);
+                update.message(message);
+                supervisor.recordLog(`operation benchmark: ${message}`);
+            },
+        });
+        ensureActive();
+        results.save({
+            model: targetModel,
+            profile,
+            report,
+            gpu: gpuInfo,
+            runtime: supervisor.runtime
+                ? `${supervisor.runtime.label} v${supervisor.runtime.version}`
+                : "unknown runtime",
+            archiveId,
+            args: supervisor.args,
+            fit,
+            calibration,
+            suite: { execute: true, concurrency: 3, depths: null, only: null, mined: false },
+        });
+        update.percent(100);
+        supervisor.recordLog(`operation benchmark: saved result for ${targetModel.displayName}`);
+    };
+    const jobs = new ServiceJobRunner(rescanCatalog, runResidentJob);
     // Assigned once `stop` exists below. This indirection lets the management API
     // answer a remote restart request before closing its own socket.
     let requestRestart = () => { };
     const hostApi = createHostApi({
         supervisor,
         getCatalog: () => catalog,
-        rescan: () => {
-            catalog = scanModels(config, env);
-            return catalog;
-        },
+        rescan: rescanCatalog,
         getProfilesStore: () => store,
         saveProfiles: (next) => saveProfilesStore(next, paths),
         getProfileDefaults: () => config.defaults,
@@ -469,6 +667,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     certManager?.start();
     if (model && profile && runtime) {
         await supervisor.start(model, profile);
+        delete store.pendingReloadModelIds[model.id];
         store.lastModelId = model.id;
         saveProfilesStore(store, paths);
     }

package/dist/service/supervisor.d.ts

@@ -1,7 +1,8 @@
 import { type ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { type BrainPaths } from "../config/paths.js";
 import type { Model, Runtime } from "../types.js";
-import type { Profile } from "../config/schema.js";
+import type { Profile, ProfilesStore } from "../config/schema.js";
 /**
  * Default loopback port for the private llama-server child. Deliberately clear
  * of Otto's space: 8081 (the old default) is the Expo/Metro dev port, so a brain
@@ -19,6 +20,14 @@ export interface SupervisorOptions {
     internalPort?: number;
     host?: string;
     readyTimeoutMs?: number;
+    /**
+     * Long-lived hosts provide their live store so profile edits applied just
+     * before a model switch are visible without a second disk read. Standalone
+     * operations use the current persisted store, which still preserves the
+     * launch-resolution invariant.
+     */
+    paths?: BrainPaths;
+    getProfilesStore?: () => ProfilesStore;
 }
 export interface SupervisorStatus {
     state: SupervisorState;
@@ -44,6 +53,8 @@ export declare class Supervisor extends EventEmitter {
     internalPort: number;
     host: string;
     readyTimeoutMs: number;
+    paths: BrainPaths;
+    getProfilesStore: () => ProfilesStore;
     state: SupervisorState;
     child: ChildProcess | null;
     model: Model | null;
@@ -61,10 +72,27 @@ export declare class Supervisor extends EventEmitter {
      * shell line is for reading, not for re-parsing.
      */
     args: string[] | null;
-    constructor({ runtime, internalPort, host, readyTimeoutMs, }: SupervisorOptions);
+    constructor({ runtime, internalPort, host, readyTimeoutMs, paths, getProfilesStore, }: SupervisorOptions);
     get upstreamBase(): string;
-    /** Start (or restart) the server for a model + profile. */
-    start(model: Model, profile: Profile): Promise<this>;
+    /**
+     * Add a host-operation event to the same bounded tail as llama-server output.
+     *
+     * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
+     * than creating invisible sidecar servers. Their lifecycle markers belong in
+     * the same log stream as the child they exercise.
+     */
+    recordLog(line: string): void;
+    /**
+     * 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
+     * caller, including future maintenance operations that start a sidecar.
+     */
+    start(model: Model, profile: Profile, options?: {
+        preserveLogs?: boolean;
+    }): Promise<this>;
     /** Fetch /props from the running server (modalities, template caps, defaults). */
     props(): Promise<unknown>;
     stop(): Promise<void>;

package/dist/service/supervisor.js

@@ -8,6 +8,9 @@ import http from "node:http";
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { buildArgs, buildEnv, formatCommand } from "../runtime/index.js";
+import { resolveHostingProfileForLaunch } from "../config/hosting-profiles.js";
+import { resolveBrainPaths } from "../config/paths.js";
+import { loadProfilesStore } from "../config/store.js";
 import { usedBytes } from "../gpu.js";
 const LOG_LINES_KEPT = 300;
 /**
@@ -28,13 +31,15 @@ export const DEFAULT_INTERNAL_PORT = 20800;
  * 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", readyTimeoutMs = 300000, }) {
+    constructor({ runtime, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", readyTimeoutMs = 300000, paths = resolveBrainPaths(), getProfilesStore = loadProfilesStore, }) {
         super();
         _Supervisor_instances.add(this);
         this.runtime = runtime;
         this.internalPort = internalPort;
         this.host = host;
         this.readyTimeoutMs = readyTimeoutMs;
+        this.paths = paths;
+        this.getProfilesStore = getProfilesStore;
         this.state = "stopped"; // stopped | starting | ready | failed
         this.child = null;
         this.model = null;
@@ -51,8 +56,25 @@ export class Supervisor extends EventEmitter {
     get upstreamBase() {
         return `http://${this.host}:${this.internalPort}`;
     }
-    /** Start (or restart) the server for a model + profile. */
-    async start(model, profile) {
+    /**
+     * Add a host-operation event to the same bounded tail as llama-server output.
+     *
+     * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
+     * than creating invisible sidecar servers. Their lifecycle markers belong in
+     * the same log stream as the child they exercise.
+     */
+    recordLog(line) {
+        __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, line);
+    }
+    /**
+     * 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
+     * caller, including future maintenance operations that start a sidecar.
+     */
+    async start(model, profile, options = {}) {
         await this.stop();
         if (!this.runtime) {
             this.lastError = "no llama.cpp runtime available";
@@ -60,13 +82,15 @@ export class Supervisor extends EventEmitter {
             throw new Error(this.lastError);
         }
         const runtime = this.runtime;
+        const launchProfile = resolveHostingProfileForLaunch(this.paths, this.getProfilesStore(), profile, model.family);
         this.model = model;
-        this.profile = profile;
+        this.profile = launchProfile;
         this.lastError = null;
-        this.logLines = [];
+        if (!options.preserveLogs)
+            this.logLines = [];
         this.vramBaselineBytes = await usedBytes();
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "starting");
-        const args = buildArgs({ ...profile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port: this.internalPort, host: this.host });
+        const args = buildArgs({ ...launchProfile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port: this.internalPort, host: this.host }, model);
         this.args = args;
         this.command = formatCommand(runtime, args);
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, `launching: ${this.command}`);

package/dist/tui/app.js

@@ -162,7 +162,7 @@ export class App {
         this.rankings = new Map(); // model id/name -> averaged benchmark rank + score
         this.rankedModels = []; // ranked list (mean of runs), best first | help
         this.telemetry = new Telemetry();
-        this.supervisor = new Supervisor({ runtime });
+        this.supervisor = new Supervisor({ runtime, getProfilesStore: () => this.store });
         this.routerServer = null;
         this.supervisor.on("state", () => this.draw());
         this.supervisor.on("log", () => {