@otto-code/brain 0.8.10 → 0.8.12

package/dist/service/activity.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _ReasoningTracker_instances, _ReasoningTracker_requests, _ReasoningTracker_tails, _ReasoningTracker_inlineReasoning, _ReasoningTracker_listeners, _ReasoningTracker_lastSnapshot, _ReasoningTracker_announce;
+var _ReasoningTracker_instances, _ReasoningTracker_requests, _ReasoningTracker_slots, _ReasoningTracker_tails, _ReasoningTracker_inlineReasoning, _ReasoningTracker_listeners, _ReasoningTracker_lastSnapshot, _ReasoningTracker_announce;
 /**
  * What long-running work currently owns the brain, and which stage each live
  * inference request has reached.
@@ -197,6 +197,12 @@ export class ReasoningTracker {
     constructor() {
         _ReasoningTracker_instances.add(this);
         _ReasoningTracker_requests.set(this, new Map());
+        /**
+         * The llama-server slot a request was pinned to at dispatch, so its proxy-side
+         * stage can be attributed to the engine row the panel actually shows. Set once
+         * per request (see `setSlot`), never on the per-chunk path.
+         */
+        _ReasoningTracker_slots.set(this, new Map());
         /** Tail of the last transport chunk, so a field name split by TCP is still detected. */
         _ReasoningTracker_tails.set(this, new Map());
         /** Models/runtimes that leave reasoning inline as `<think>…</think>`. */
@@ -222,6 +228,24 @@ export class ReasoningTracker {
         __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "processing");
         __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
     }
+    /**
+     * Record the engine slot this request was pinned to. Called exactly once per
+     * request, at dispatch - the pin is injected into the outbound body before
+     * the request goes out, so the association exists before the first chunk and
+     * `observe` never has to learn about it.
+     *
+     * Idempotent and self-cleaning: a repeat for the same slot is a no-op, and a
+     * different slot replaces it, so a request that somehow moves slots (a
+     * restarted engine hands a task out again) reports where it is now.
+     */
+    setSlot(requestId, slotId) {
+        if (!Number.isInteger(slotId) || slotId < 0)
+            return;
+        if (__classPrivateFieldGet(this, _ReasoningTracker_slots, "f").get(requestId) === slotId)
+            return;
+        __classPrivateFieldGet(this, _ReasoningTracker_slots, "f").set(requestId, slotId);
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+    }
     /** Note a chunk of `requestId`'s stream. Cheap enough to call per chunk. */
     observe(requestId, text) {
         const current = __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").get(requestId);
@@ -261,6 +285,7 @@ export class ReasoningTracker {
     /** Forget the request. Must be called on end *and* on error, or the flag sticks. */
     end(requestId) {
         __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").delete(requestId);
+        __classPrivateFieldGet(this, _ReasoningTracker_slots, "f").delete(requestId);
         __classPrivateFieldGet(this, _ReasoningTracker_tails, "f").delete(requestId);
         __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").delete(requestId);
         __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
@@ -279,14 +304,32 @@ export class ReasoningTracker {
             thinking: 0,
             generating: 0,
         };
-        for (const stage of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").values())
+        let slotStages;
+        for (const [requestId, stage] of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f")) {
             result[stage] += 1;
+            const slot = __classPrivateFieldGet(this, _ReasoningTracker_slots, "f").get(requestId);
+            if (slot === undefined)
+                continue;
+            (slotStages ?? (slotStages = {}))[String(slot)] = stage;
+        }
+        if (slotStages)
+            result.slotStages = slotStages;
         return result;
     }
 }
-_ReasoningTracker_requests = new WeakMap(), _ReasoningTracker_tails = new WeakMap(), _ReasoningTracker_inlineReasoning = new WeakMap(), _ReasoningTracker_listeners = new WeakMap(), _ReasoningTracker_lastSnapshot = new WeakMap(), _ReasoningTracker_instances = new WeakSet(), _ReasoningTracker_announce = function _ReasoningTracker_announce() {
+_ReasoningTracker_requests = new WeakMap(), _ReasoningTracker_slots = new WeakMap(), _ReasoningTracker_tails = new WeakMap(), _ReasoningTracker_inlineReasoning = new WeakMap(), _ReasoningTracker_listeners = new WeakMap(), _ReasoningTracker_lastSnapshot = new WeakMap(), _ReasoningTracker_instances = new WeakSet(), _ReasoningTracker_announce = function _ReasoningTracker_announce() {
     const snapshot = this.snapshot;
-    const key = `${snapshot.activeRequests}:${snapshot.processing}:${snapshot.thinking}:${snapshot.generating}`;
+    // The slot join rides in the key too: pinning a request to a slot is a
+    // state change even when no stage count moves, and it is the field the
+    // Overview rows read. The map is bounded by concurrency, so the digest is
+    // cheap enough to build on every announce.
+    const slotKey = snapshot.slotStages
+        ? Object.entries(snapshot.slotStages)
+            .map(([slot, stage]) => `${slot}:${stage}`)
+            .sort()
+            .join(",")
+        : "";
+    const key = `${snapshot.activeRequests}:${snapshot.processing}:${snapshot.thinking}:${snapshot.generating}:${slotKey}`;
     if (key === __classPrivateFieldGet(this, _ReasoningTracker_lastSnapshot, "f"))
         return;
     __classPrivateFieldSet(this, _ReasoningTracker_lastSnapshot, key, "f");

package/dist/service/host-api.d.ts

@@ -26,8 +26,11 @@ import type { RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
 import * as vram from "../vram.js";
 import type { SystemSample } from "../sysmon.js";
-import type { BrainStatusPublisher } from "./status-events.js";
+import type { BrainLogPublisher, BrainStatusPublisher } from "./status-events.js";
 import type { Supervisor } from "./supervisor.js";
+import type { Scheduler } from "./scheduler.js";
+import type { BrainRunLog } from "./run-log.js";
+import type { BrainLogArea } from "./log-format.js";
 /**
  * The management API's own version, additive to the capability flags.
  *
@@ -72,6 +75,8 @@ export interface HostCapabilities {
     events: boolean;
     /** Bounded live inference stages, token counts and throughput on status events. */
     liveInference: boolean;
+    /** Every completed Brain log line arrives immediately on the SSE stream. */
+    logEvents: boolean;
     /** Whether writes are currently permitted (allowRemoteConfig). */
     writable: boolean;
     /** POST/GET /__host/jobs and POST /__host/jobs/cancel. */
@@ -86,6 +91,8 @@ export interface HostJob {
     label: string;
     target: string | null;
     status: "running" | "succeeded" | "failed" | "canceled";
+    /** Positive while the shared scheduler has not admitted this operation yet. */
+    queuePosition?: number | null;
     percent: number | null;
     message: string | null;
     error: string | null;
@@ -93,10 +100,15 @@ export interface HostJob {
     finishedAt: string | null;
 }
 export interface HostJobRunner {
-    start: (kind: HostJob["kind"], target: string | null, args: string[]) => HostJob;
+    start: (kind: HostJob["kind"], target: string | null, args: string[], 
+    /** A bundle entry owns its companion-artifact queue, not the whole host. */
+    pull?: {
+        entryKey: string;
+        components: string[];
+    }) => HostJob;
     list: () => HostJob[];
     cancel: (jobId: string) => Promise<HostJob[]>;
-    query: (args: string[]) => Promise<unknown>;
+    query: (args: string[], area?: BrainLogArea) => Promise<unknown>;
 }
 export interface HostApiDeps {
     supervisor: Supervisor;
@@ -110,6 +122,8 @@ export interface HostApiDeps {
     queryGpuInfo: () => Promise<GpuInfo | null>;
     getRanking: () => RankedModel[];
     loadModel: (model: Model) => Promise<void>;
+    /** The single model queue shared by completions and resident operations. */
+    scheduler?: Scheduler | null;
     /** Mirrors POST /__host/config's gate: may a network caller change things? */
     getAllowWrite: () => boolean;
     /** The managed models directory, for disk accounting. Null when unresolvable. */
@@ -121,10 +135,16 @@ export interface HostApiDeps {
      * its daemon keeps polling status.
      */
     statusEvents?: BrainStatusPublisher | null;
+    /** The append-only line stream behind `GET /__host/events`. */
+    logEvents?: BrainLogPublisher | null;
     /** Long operations that must execute on this brain's machine. */
     jobs?: HostJobRunner;
+    /** The append-only log owned by this Brain service run. */
+    runLog?: BrainRunLog;
     /** Gracefully restart the serving process after its HTTP acknowledgement. */
     restart?: () => void;
+    /** Durable service-session operation log. */
+    log?: (area: BrainLogArea, message: string) => void;
 }
 /** One row of the model inventory: the scan, metadata, profile and score joined. */
 export interface InventoryRow {
@@ -153,7 +173,7 @@ export interface InventoryRow {
     budget: vram.Budget | null;
     maxContextThatFits: number | null;
     score: RankedModel | null;
-    state: "loaded" | "loading" | "not-loaded";
+    state: "loaded" | "loading" | "unloading" | "active" | "queued" | "not-loaded";
     warnings: ReturnType<typeof profileWarnings>;
     components: NonNullable<Model["components"]> | null;
 }
@@ -184,6 +204,7 @@ export declare function buildInventoryRow(params: {
     gpu: GpuInfo | null;
     ranking: RankedModel[];
     supervisor: Supervisor;
+    scheduler?: Scheduler | null;
     runtimeBuild?: number | null;
 }): InventoryRow;
 export interface HostApi {

package/dist/service/host-api.js

@@ -170,13 +170,21 @@ function hostingProfilesFor(store, model) {
     const family = hostingFamily(model.family);
     return Object.values(store.hostingProfiles).filter((candidate) => candidate.family === family);
 }
-function stateOf(supervisor, model) {
-    if (!supervisor.model || supervisor.model.id !== model.id)
-        return "not-loaded";
-    if (supervisor.state === "ready")
+function stateOf(supervisor, scheduler, model) {
+    const resident = supervisor.model?.id === model.id;
+    if (resident) {
+        if (supervisor.state === "starting")
+            return "loading";
+        if (supervisor.state === "stopping")
+            return "unloading";
+    }
+    const stats = scheduler?.stats();
+    if (stats?.active?.modelId === model.id)
+        return "active";
+    if ((stats?.waitingModelIds[model.id] ?? 0) > 0)
+        return "queued";
+    if (resident && supervisor.state === "ready")
         return "loaded";
-    if (supervisor.state === "starting")
-        return "loading";
     return "not-loaded";
 }
 /**
@@ -187,7 +195,7 @@ function stateOf(supervisor, model) {
  * client would otherwise have to correlate three unrelated lists by display name.
  */
 export function buildInventoryRow(params) {
-    const { model, store, defaults, gpu, ranking, supervisor, runtimeBuild: activeRuntimeBuild = null, } = params;
+    const { model, store, defaults, gpu, ranking, supervisor, scheduler = null, runtimeBuild: activeRuntimeBuild = null, } = params;
     const profile = forModel(store, model, defaults);
     const calibration = profile.calibrationRequired ? null : getCalibration(store, model, profile);
     const budgetOptions = gpu
@@ -222,7 +230,7 @@ export function buildInventoryRow(params) {
         budget: budgetOptions ? vram.budget(budgetOptions) : null,
         maxContextThatFits: budgetOptions ? vram.maxContextThatFits(budgetOptions) : null,
         score: ranked,
-        state: stateOf(supervisor, model),
+        state: stateOf(supervisor, scheduler, model),
         warnings: profileWarnings(profile, model, store),
         components: model.components?.map((component) => {
             if (component.minRuntimeBuild === undefined ||
@@ -267,7 +275,23 @@ function resolveModel(catalog, needle) {
  */
 function profileFromQuery(base, params, model) {
     const patch = {};
-    const numeric = ["contextSize", "gpuLayers", "parallelSlots", "reasoningBudget"];
+    // The samplers cost no VRAM and so change nothing in the budget this powers,
+    // but they ride in the same draft the editor sends. Parse them anyway: an
+    // unparsed key reaches sanitizeProfilePatch as the string "0.8" and throws,
+    // which would fail the whole preview over a field it does not even price.
+    const numeric = [
+        "contextSize",
+        "gpuLayers",
+        "parallelSlots",
+        "cachedChats",
+        "reasoningBudget",
+        "temperature",
+        "topP",
+        "topK",
+        "minP",
+        "presencePenalty",
+        "repeatPenalty",
+    ];
     for (const key of numeric) {
         const raw = params.get(key);
         if (raw !== null && raw !== "")
@@ -283,6 +307,16 @@ function profileFromQuery(base, params, model) {
         if (raw !== null && raw !== "")
             patch[key] = raw === "true" || raw === "1";
     }
+    // Tri-state, and every spelling a client might use for it. Unknown text is
+    // dropped rather than thrown on: this field prices nothing, so a value this
+    // route cannot read must not take the whole budget preview down with it.
+    const preserve = params.get("preserveReasoning");
+    if (preserve === "true" || preserve === "on")
+        patch.preserveReasoning = true;
+    else if (preserve === "false" || preserve === "off")
+        patch.preserveReasoning = false;
+    else if (preserve === "default" || preserve === "null")
+        patch.preserveReasoning = null;
     if (Object.keys(patch).length === 0)
         return base;
     return sanitizeProfilePatch(base, patch, model, runtimeBuild(null)).profile;
@@ -306,6 +340,7 @@ export function createHostApi(deps) {
         // would make a daemon stop polling and see nothing.
         events: Boolean(deps.statusEvents?.ready),
         liveInference: Boolean(deps.statusEvents?.ready),
+        logEvents: Boolean(deps.statusEvents?.ready && deps.logEvents),
         writable: deps.getAllowWrite(),
         jobs: Boolean(deps.jobs),
         restart: Boolean(deps.restart),
@@ -328,6 +363,7 @@ export function createHostApi(deps) {
             gpu,
             ranking,
             supervisor: deps.supervisor,
+            scheduler: deps.scheduler,
             runtimeBuild: runtimeBuild(deps.supervisor.runtime),
         }));
     };
@@ -381,6 +417,7 @@ export function createHostApi(deps) {
                     if (requiresRestart)
                         store.pendingReloadModelIds[model.id] = true;
                     deps.saveProfiles(store);
+                    deps.log?.("model", `updated profile for ${model.displayName}${requiresRestart ? "; reload required" : ""}`);
                     // Return the recomputed budget so an edit costs one round trip rather
                     // than a write followed by a read the UI has to sequence.
                     const gpu = await deps.queryGpuInfo();
@@ -448,6 +485,7 @@ export function createHostApi(deps) {
             // the brain is restarted. Reset already follows this pattern below.
             const catalog = deps.rescan();
             const updated = resolveModel(catalog, model.id);
+            deps.log?.("library", `renamed ${model.displayName} to ${displayName}`);
             sendJson(res, { displayName: updated ? updated.displayName : displayName });
         });
     };
@@ -460,6 +498,7 @@ export function createHostApi(deps) {
             deleteDisplayName(model.id);
             const catalog = deps.rescan();
             const updated = resolveModel(catalog, model.id);
+            deps.log?.("library", `reset display name for ${model.displayName}`);
             sendJson(res, { displayName: updated ? updated.displayName : model.displayName });
         });
     };
@@ -511,7 +550,9 @@ export function createHostApi(deps) {
                 return;
             }
             try {
+                deps.log?.("model", `loading ${model.displayName}`);
                 await deps.loadModel(model);
+                deps.log?.("model", `loaded ${model.displayName}`);
                 sendJson(res, {
                     status: deps.supervisor.status(),
                     // What actually got used: loadModel fits the profile to VRAM, so the
@@ -520,6 +561,7 @@ export function createHostApi(deps) {
                 });
             }
             catch (error) {
+                deps.log?.("model", `failed to load ${model.displayName}: ${errorMessage(error)}`);
                 sendError(res, 409, `could not load ${model.displayName}: ${errorMessage(error)}`);
             }
         })();
@@ -527,7 +569,9 @@ export function createHostApi(deps) {
     const handleUnload = (res) => {
         void (async () => {
             try {
+                deps.log?.("model", "unloading resident model");
                 await deps.supervisor.stop();
+                deps.log?.("model", "resident model unloaded");
                 sendJson(res, { status: deps.supervisor.status() });
             }
             catch (error) {
@@ -543,6 +587,7 @@ export function createHostApi(deps) {
         try {
             const plan = deleteModelFiles(model);
             const catalog = deps.rescan();
+            deps.log?.("library", `deleted ${model.displayName}; freed ${plan.bytes} bytes`);
             sendJson(res, {
                 deleted: plan.files,
                 freedBytes: plan.bytes,
@@ -562,6 +607,7 @@ export function createHostApi(deps) {
         try {
             const plan = deleteComponentFile(model, componentId);
             deps.rescan();
+            deps.log?.("library", `deleted ${componentId} from ${model.displayName}; freed ${plan.bytes} bytes`);
             sendJson(res, {
                 deleted: plan.files,
                 freedBytes: plan.bytes,
@@ -575,10 +621,11 @@ export function createHostApi(deps) {
     const handleLogs = (res, params) => {
         const raw = Number(params.get("limit"));
         const limit = Number.isFinite(raw) && raw > 0 ? Math.min(Math.round(raw), 1000) : DEFAULT_LOG_LINES;
+        const session = deps.runLog?.tail(limit);
         const all = deps.supervisor.logLines;
         sendJson(res, {
-            lines: all.slice(-limit),
-            total: all.length,
+            lines: session?.lines ?? all.slice(-limit),
+            total: session?.total ?? all.length,
             state: deps.supervisor.state,
             command: deps.supervisor.command,
         });
@@ -610,7 +657,13 @@ export function createHostApi(deps) {
                 return;
             res.write(`event: status\ndata: ${JSON.stringify(snapshot)}\n\n`);
         };
+        const writeLog = (line) => {
+            if (res.writableEnded || res.destroyed)
+                return;
+            res.write(`event: log\ndata: ${JSON.stringify({ line })}\n\n`);
+        };
         let unsubscribe = () => { };
+        let unsubscribeLogs = () => { };
         const keepalive = setInterval(() => {
             if (res.writableEnded || res.destroyed)
                 return;
@@ -620,6 +673,7 @@ export function createHostApi(deps) {
         const teardown = () => {
             clearInterval(keepalive);
             unsubscribe();
+            unsubscribeLogs();
         };
         // The publisher ends the response on host shutdown: an open SSE response is
         // an open connection, and `server.close()` waits for those.
@@ -628,6 +682,7 @@ export function createHostApi(deps) {
             if (!res.writableEnded && !res.destroyed)
                 res.end();
         });
+        unsubscribeLogs = deps.logEvents?.subscribe(writeLog) ?? (() => { });
         // Both ends matter: `close` on the request covers a client that walked away,
         // and `close` on the response covers the service shutting the socket down.
         req.on("close", teardown);
@@ -664,6 +719,7 @@ export function createHostApi(deps) {
             }
             if (!guardWrite(res))
                 return true;
+            deps.log?.("server", "restart requested through the management API");
             sendJson(res, { accepted: true });
             queueMicrotask(() => deps.restart?.());
             return true;
@@ -737,6 +793,7 @@ export function createHostApi(deps) {
                             "--",
                             model,
                         ],
+                        pull: { entryKey: model, components: components ?? [] },
                     };
                 },
             },
@@ -763,6 +820,7 @@ export function createHostApi(deps) {
                             "--",
                             repo,
                         ],
+                        pull: { entryKey: `${repo}#${quant}`, components: components ?? [] },
                     };
                 },
             },
@@ -838,7 +896,9 @@ export function createHostApi(deps) {
                 }
                 try {
                     const spec = start.makeArgs(result.body);
-                    sendJson(res, { job: deps.jobs?.start(start.kind, spec.target, spec.args) ?? null });
+                    sendJson(res, {
+                        job: deps.jobs?.start(start.kind, spec.target, spec.args, spec.pull) ?? null,
+                    });
                 }
                 catch (error) {
                     sendError(res, 400, errorMessage(error));
@@ -847,27 +907,32 @@ export function createHostApi(deps) {
             return true;
         }
         if (route === "/__host/catalog" && method === "GET") {
-            void deps.jobs?.query(["catalog", "--json"]).then((models) => sendJson(res, { models }));
+            deps.log?.("library", "refreshing the model catalog");
+            void deps.jobs
+                ?.query(["catalog", "--json"], "library")
+                .then((models) => sendJson(res, { models }));
             return true;
         }
         if (route === "/__host/runtimes" && method === "GET") {
             void deps.jobs
-                ?.query(["runtime", "list", "--json"])
+                ?.query(["runtime", "list", "--json"], "library")
                 .then((runtimes) => sendJson(res, { runtimes }));
             return true;
         }
         if (route === "/__host/hf/search" && method === "GET") {
             const query = params.get("query") ?? "";
             const limit = Math.max(1, Math.min(100, Number(params.get("limit")) || 25));
+            deps.log?.("library", `searching Hugging Face for ${JSON.stringify(query)} (limit ${limit})`);
             void deps.jobs
-                ?.query(["search", "--json", "--limit", String(limit), "--", query])
+                ?.query(["search", "--json", "--limit", String(limit), "--", query], "library")
                 .then((results) => sendJson(res, { results }));
             return true;
         }
         if (route === "/__host/hf/quants" && method === "GET") {
             const repo = params.get("repo") ?? "";
+            deps.log?.("library", `listing Hugging Face quants for ${repo}`);
             void deps.jobs
-                ?.query(["add", "--list-quants", "--json", "--", repo])
+                ?.query(["add", "--list-quants", "--json", "--", repo], "library")
                 .then((quants) => sendJson(res, { quants }));
             return true;
         }
@@ -913,6 +978,7 @@ export function createHostApi(deps) {
         // without restarting the host or unloading its resident model.
         if (route === "/__host/models/rescan" && method === "POST") {
             const models = deps.rescan();
+            deps.log?.("library", `rescanned model library: ${models.length} models`);
             sendJson(res, { models: models.length });
             return true;
         }

package/dist/service/log-format.d.ts

@@ -0,0 +1,18 @@
+/** Stable source and subsystem markers for the one Brain service-session log. */
+export type BrainLogArea = "library" | "model" | "api" | "server";
+/**
+ * Every service-owned event carries both its process source and operation area.
+ * llama-server output is separately marked by `formatLlamaServerLog`.
+ */
+export declare function formatBrainLog(area: BrainLogArea, message: string): string;
+/**
+ * Remove llama.cpp's elapsed-time, level and component columns. Otto owns the
+ * timestamp and source marker, and the remaining message is what an operator
+ * needs to diagnose the runtime.
+ */
+export declare function stripLlamaServerPrefix(message: string): string;
+/** Preserve the useful llama.cpp message while making its process boundary explicit. */
+export declare function formatLlamaServerLog(message: string): string;
+/** Place source tags ahead of the timestamp so they are scannable in a dense log. */
+export declare function timestampBrainLogLine(timestamp: string, line: string): string;
+//# sourceMappingURL=log-format.d.ts.map

package/dist/service/log-format.js

@@ -0,0 +1,32 @@
+const TAGGED_LINE = /^\[(?:brain|llama-server)\]/u;
+const SOURCE_AND_AREA = /^(\[(?:brain|llama-server)\])(?:\s+(\[(?:library|model|api|server)\]))?\s*(.*)$/u;
+const LLAMA_SERVER_PREFIX = /^\d+(?:\.\d+){3}\s+[A-Z]\s+\S+\s+(?:\S+:\s+)?(.+)$/u;
+/**
+ * Every service-owned event carries both its process source and operation area.
+ * llama-server output is separately marked by `formatLlamaServerLog`.
+ */
+export function formatBrainLog(area, message) {
+    return TAGGED_LINE.test(message) ? message : `[brain] [${area}] ${message}`;
+}
+/**
+ * Remove llama.cpp's elapsed-time, level and component columns. Otto owns the
+ * timestamp and source marker, and the remaining message is what an operator
+ * needs to diagnose the runtime.
+ */
+export function stripLlamaServerPrefix(message) {
+    return LLAMA_SERVER_PREFIX.exec(message)?.[1] ?? message;
+}
+/** Preserve the useful llama.cpp message while making its process boundary explicit. */
+export function formatLlamaServerLog(message) {
+    return TAGGED_LINE.test(message) ? message : `[llama-server] ${stripLlamaServerPrefix(message)}`;
+}
+/** Place source tags ahead of the timestamp so they are scannable in a dense log. */
+export function timestampBrainLogLine(timestamp, line) {
+    const tagged = formatBrainLog("server", line);
+    const match = SOURCE_AND_AREA.exec(tagged);
+    if (!match)
+        return `${timestamp} ${tagged}`;
+    const [, source, area, message] = match;
+    return `${source}${area ? ` ${area}` : ""} ${timestamp}${message ? ` ${message}` : ""}`;
+}
+//# sourceMappingURL=log-format.js.map

package/dist/service/router.d.ts

@@ -1,4 +1,5 @@
 import http from "node:http";
+import { Scheduler } from "./scheduler.js";
 import type { Supervisor } from "./supervisor.js";
 import { type RankedModel } from "../ops/results.js";
 import type { GpuInfo, Model } from "../types.js";
@@ -6,8 +7,9 @@ import type { Profile } from "../config/schema.js";
 import { type HostApi } from "./host-api.js";
 import type { BrainStatusPublisher } from "./status-events.js";
 type Verdict = "ok" | "reasoning-only" | "truncated" | "failed";
-/** A logger sink; only `warn` is used by the router. */
+/** Optional durable operational-log sink for completion lifecycle events. */
 export interface Logger {
+    info?(message: string): void;
     warn(message: string): void;
 }
 /** A source of the catalog: a getter, a snapshot array, or nothing. */
@@ -88,6 +90,8 @@ export interface ModelEntry {
     reasoning: boolean;
     /** Optional per-model values accepted by the OpenAI-compatible endpoint. */
     reasoning_efforts?: string[];
+    /** Optional model-native default among `reasoning_efforts`. */
+    reasoning_effort_default?: string;
     loaded_context_length?: number;
 }
 /**
@@ -105,6 +109,68 @@ export declare function describeModel(model: Model | null, options?: DescribeOpt
  * model when no catalog provider is wired in.
  */
 export declare function buildModelList(supervisor: Supervisor, getCatalog: GetCatalog): ModelEntry[];
+/**
+ * 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.
+ */
+export declare function applyModelReasoningTemplate(body: Buffer, model: Model): Buffer;
+/**
+ * Pin the request to one llama-server slot by adding the engine's own
+ * `id_slot` field to the request body (host API v3).
+ *
+ * Why pin instead of guess: the OpenAI-compatible stream chunks never carry the
+ * slot id, so without a pin the router can only correlate a request to a slot
+ * by elimination, and with several concurrent requests that guess is exactly
+ * the lie the Overview panel used to tell. llama-server honors the pin on every
+ * completion endpoint: if the named slot is free the task lands there, and if
+ * it is busy the engine DEFERS the task internally - it never reassigns the
+ * task elsewhere and never fails the request - so the slot this router names is
+ * always the slot the request ends up on (possibly after waiting on it).
+ *
+ * `null` returns the body untouched: no pin, and therefore no join data for
+ * this request, which is the same degraded state as an older brain. A body this
+ * cannot parse is forwarded exactly as-is - an unfamiliar request must reach
+ * llama-server and get llama-server's own answer, not a 400 invented here.
+ */
+export declare function pinSlot(body: Buffer, slotId: number | null): Buffer;
+/**
+ * Wipe one llama-server slot's retained KV state, and RESOLVE only once the
+ * engine has acknowledged the wipe.
+ *
+ * This is the engine-side half of the scheduler's OWNERSHIP fix. The engine
+ * never clears a released slot's prompt, so a slot handed to a different chat
+ * would keep the previous chat's KV and bleed its topics into the new chat's
+ * thinking. The router erases the slot the moment the scheduler hands it off;
+ * the engine's task queue runs in arrival order, so resolving on the
+ * acknowledgment is what guarantees the clean state sits in the queue ahead of
+ * the completion the scheduler posts right after.
+ *
+ * The route is `POST /slots?action=erase&id_slot=N` - llama.cpp's own slot
+ * action. It answers 200 `{id, id_slot, n_erased}` on success and a
+ * `NOT_SUPPORTED` error when the server was not launched with a slot-save path;
+ * either way this resolves (never rejects), because an erase that cannot be
+ * performed degrades to the old behavior rather than failing the completion.
+ *
+ * NOTE: `action` and `id_slot` MUST travel in the query string, not the JSON
+ * body. llama-server's `POST /slots` handler reads both via `req.get_param()`,
+ * which is built only from query + path params (b10441 tools/server/server-http.cpp,
+ * `server_http_req::params` = "path_params + query_params"; the body is a
+ * separate field the handler never parses for this route). A body-only request
+ * reaches `std::stoi("")` and answers 400 "Invalid slot ID" - the erase then
+ * silently no-ops and the bleed survives. The body must stay empty for the
+ * same reason `handle_slots_erase` ignores it entirely.
+ */
+export declare function eraseSlot(host: string, port: number, slotId: number): Promise<void>;
+/**
+ * The eraser the scheduler needs, bound to one engine endpoint. Extracted so
+ * the router (which builds its own scheduler) and the service (which builds a
+ * shared one and passes it in) hand the scheduler the SAME transport rather
+ * than each spelling the request.
+ */
+export declare function createSlotEraser(host: string, port: number): (slotId: number) => Promise<void>;
 /** Which shape a completion path uses to carry its system turn. */
 export type CompletionShape = "anthropic" | "openai";
 export declare function completionShape(url: string | null | undefined): CompletionShape;
@@ -195,7 +261,9 @@ export interface RouterOptions {
      * can never disagree. Absent means this brain does not advertise events.
      */
     statusEvents?: BrainStatusPublisher | null;
+    /** A service shares this scheduler with host-owned model operations. */
+    scheduler?: Scheduler | null;
 }
-export declare function createRouter({ supervisor, telemetry, logger, getCatalog, loadModel, loadRanking, queryGpuInfo, version, getConfig, getEvals, getLockModel, getDefaultModel, applyConfigPatch, getAllowConfigWrite, hostApi, getResources, statusEvents, }: RouterOptions): (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare function createRouter({ supervisor, telemetry, logger, getCatalog, loadModel, loadRanking, queryGpuInfo, version, getConfig, getEvals, getLockModel, getDefaultModel, applyConfigPatch, getAllowConfigWrite, hostApi, getResources, statusEvents, scheduler: suppliedScheduler, }: RouterOptions): (req: http.IncomingMessage, res: http.ServerResponse) => void;
 export {};
 //# sourceMappingURL=router.d.ts.map