@otto-code/brain 0.8.10 → 0.8.13

package/dist/runtime/managed.js

@@ -38,8 +38,8 @@
  *    also needs `libcublas`, `libcudart` and `libnccl.so.2` - and NCCL ships in
  *    neither NVIDIA redistributable. Do not reopen this without a measurement on
  *    hardware that does *not* report NV_coopmat2, which is the one case where
- *    the gap could still be real. Full evidence:
- *    findings/linux-gpu-acceleration/2026-08-04-cuda-vs-vulkan-and-cuda-asset-origins.md
+ *    the gap could still be real. Measured 2026-08-04; the full method and
+ *    numbers are the "cuda vs vulkan" finding in Otto Knowledge.
  *  - **No Linux asset ships `libgomp.so.1`**, which `llama-server` hard-links,
  *    so a host without `libgomp1` installs a runtime that then exits 127 on
  *    spawn. Windows bundles its OpenMP runtime (`libomp140.x86_64.dll`); Linux

package/dist/service/activity.d.ts

@@ -64,6 +64,14 @@ export interface InferenceActivitySnapshot {
     processing: number;
     thinking: number;
     generating: number;
+    /**
+     * Per-slot stage join, present only when at least one tracked request was
+     * pinned to a llama-server slot by the router (host API v3). Keys are the
+     * engine's slot ids as reported by `/slots`; values are that request's
+     * proxy-side stage. Absent (not just empty) on brains that predate the join,
+     * which is how an old client tells "no join data" from "no pinned requests".
+     */
+    slotStages?: Record<string, InferenceStage>;
 }
 /**
  * Which in-flight completions are currently mid-thought.
@@ -91,6 +99,17 @@ export declare class ReasoningTracker {
     onChange(listener: () => void): () => void;
     /** A completion was dispatched to llama-server and awaits its first output delta. */
     begin(requestId: string): void;
+    /**
+     * 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: string, slotId: number): void;
     /** Note a chunk of `requestId`'s stream. Cheap enough to call per chunk. */
     observe(requestId: string, text: string): void;
     /** Forget the request. Must be called on end *and* on error, or the flag sticks. */

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 { ModelScheduler } 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,12 +75,16 @@ 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. */
     jobs: boolean;
     /** POST /__host/restart delegates a restart to the service owner. */
     restart: boolean;
+    /** Multiple independently supervised model processes are supported. */
+    processPool: boolean;
 }
 /** A long-running operation owned by this brain host, not its caller. */
 export interface HostJob {
@@ -86,6 +93,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 +102,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 +124,9 @@ export interface HostApiDeps {
     queryGpuInfo: () => Promise<GpuInfo | null>;
     getRanking: () => RankedModel[];
     loadModel: (model: Model) => Promise<void>;
+    unloadModels?: () => Promise<void>;
+    /** The process-pool scheduler shared by completions and resident operations. */
+    scheduler?: ModelScheduler<Supervisor> | 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 +138,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 +176,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 +207,7 @@ export declare function buildInventoryRow(params: {
     gpu: GpuInfo | null;
     ranking: RankedModel[];
     supervisor: Supervisor;
+    scheduler?: ModelScheduler<Supervisor> | null;
     runtimeBuild?: number | null;
 }): InventoryRow;
 export interface HostApi {

package/dist/service/host-api.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { calibrationInfo, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, } from "../config/profile-edit.js";
 import { familyHostingProfileId, hostingFamily, removeHostingProfileMaterialization, } from "../config/hosting-profiles.js";
-import { forModel, getCalibration, put } from "../config/profiles.js";
+import { forModel, getCalibrationForBudget, put } from "../config/profiles.js";
 import { HostingProfileSchema, } from "../config/schema.js";
 import { deleteComponentFile, deleteModelFiles, diskUsage, planDelete, totalModelBytes, } from "../models/manage.js";
 import { deleteDisplayName, updateDisplayName } from "../models/rename-map.js";
@@ -170,13 +170,23 @@ 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 residentSupervisor = (typeof scheduler?.supervisorFor === "function" ? scheduler.supervisorFor(model.id) : null) ??
+        (supervisor.model?.id === model.id ? supervisor : null);
+    const resident = residentSupervisor !== null;
+    if (resident) {
+        if (residentSupervisor.state === "starting")
+            return "loading";
+        if (residentSupervisor.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 && residentSupervisor.state === "ready")
         return "loaded";
-    if (supervisor.state === "starting")
-        return "loading";
     return "not-loaded";
 }
 /**
@@ -187,9 +197,9 @@ 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 calibration = getCalibrationForBudget(store, model, profile);
     const budgetOptions = gpu
         ? { model, profile, calibration, totalVramBytes: gpu.totalBytes }
         : null;
@@ -222,7 +232,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 +277,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 +309,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,9 +342,11 @@ 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),
+        processPool: true,
     });
     /** Refuse a write unless the owner opted into remote configuration. */
     const guardWrite = (res) => {
@@ -328,6 +366,7 @@ export function createHostApi(deps) {
             gpu,
             ranking,
             supervisor: deps.supervisor,
+            scheduler: deps.scheduler,
             runtimeBuild: runtimeBuild(deps.supervisor.runtime),
         }));
     };
@@ -377,16 +416,17 @@ export function createHostApi(deps) {
                     // A setting is only unapplied when it was changed on the currently
                     // resident model. Edits to an unloaded model take effect naturally
                     // when it is next loaded and do not earn a misleading reload badge.
-                    const requiresRestart = deps.supervisor.model?.id === model.id;
+                    const requiresRestart = Boolean((typeof deps.scheduler?.supervisorFor === "function"
+                        ? deps.scheduler.supervisorFor(model.id)
+                        : null) ?? (deps.supervisor.model?.id === model.id ? deps.supervisor : null));
                     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();
-                    const calibration = profile.calibrationRequired
-                        ? null
-                        : getCalibration(store, model, profile);
+                    const calibration = getCalibrationForBudget(store, model, profile);
                     const options = gpu
                         ? { model, profile, calibration, totalVramBytes: gpu.totalBytes }
                         : null;
@@ -448,6 +488,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 +501,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 });
         });
     };
@@ -483,7 +525,7 @@ export function createHostApi(deps) {
                 const options = {
                     model,
                     profile,
-                    calibration: profile.calibrationRequired ? null : getCalibration(store, model, profile),
+                    calibration: getCalibrationForBudget(store, model, profile),
                     totalVramBytes: gpu.totalBytes,
                 };
                 sendJson(res, {
@@ -511,15 +553,21 @@ export function createHostApi(deps) {
                 return;
             }
             try {
+                deps.log?.("model", `loading ${model.displayName}`);
                 await deps.loadModel(model);
+                deps.log?.("model", `loaded ${model.displayName}`);
+                const resident = (typeof deps.scheduler?.supervisorFor === "function"
+                    ? deps.scheduler.supervisorFor(model.id)
+                    : null) ?? deps.supervisor;
                 sendJson(res, {
-                    status: deps.supervisor.status(),
+                    status: resident.status(),
                     // What actually got used: loadModel fits the profile to VRAM, so the
                     // context here may be lower than the one saved.
-                    profile: deps.supervisor.profile,
+                    profile: resident.profile,
                 });
             }
             catch (error) {
+                deps.log?.("model", `failed to load ${model.displayName}: ${errorMessage(error)}`);
                 sendError(res, 409, `could not load ${model.displayName}: ${errorMessage(error)}`);
             }
         })();
@@ -527,7 +575,12 @@ export function createHostApi(deps) {
     const handleUnload = (res) => {
         void (async () => {
             try {
-                await deps.supervisor.stop();
+                deps.log?.("model", "unloading resident model");
+                if (deps.unloadModels)
+                    await deps.unloadModels();
+                else
+                    await deps.supervisor.stop();
+                deps.log?.("model", "resident model unloaded");
                 sendJson(res, { status: deps.supervisor.status() });
             }
             catch (error) {
@@ -536,13 +589,17 @@ export function createHostApi(deps) {
         })();
     };
     const handleDelete = (res, model) => {
-        if (deps.supervisor.model?.id === model.id && deps.supervisor.state !== "stopped") {
+        const resident = typeof deps.scheduler?.supervisorFor === "function"
+            ? deps.scheduler.supervisorFor(model.id)
+            : null;
+        if (resident && resident.state !== "stopped") {
             sendError(res, 409, "stop the model before deleting it");
             return;
         }
         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,
@@ -555,13 +612,17 @@ export function createHostApi(deps) {
         }
     };
     const handleComponentDelete = (res, model, componentId) => {
-        if (deps.supervisor.model?.id === model.id && deps.supervisor.state !== "stopped") {
+        const resident = typeof deps.scheduler?.supervisorFor === "function"
+            ? deps.scheduler.supervisorFor(model.id)
+            : null;
+        if (resident && resident.state !== "stopped") {
             sendError(res, 409, "stop the model before removing a bundle component");
             return;
         }
         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 +636,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 +672,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 +688,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 +697,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 +734,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 +808,7 @@ export function createHostApi(deps) {
                             "--",
                             model,
                         ],
+                        pull: { entryKey: model, components: components ?? [] },
                     };
                 },
             },
@@ -763,6 +835,7 @@ export function createHostApi(deps) {
                             "--",
                             repo,
                         ],
+                        pull: { entryKey: `${repo}#${quant}`, components: components ?? [] },
                     };
                 },
             },
@@ -838,7 +911,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 +922,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 +993,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