@otto-code/brain 0.8.1 → 0.8.3

package/dist/service/serve.js

@@ -23,10 +23,12 @@ import * as results from "../ops/results.js";
 import { createCpuSampler, sample as sampleSystem } from "../sysmon.js";
 import { createHostApi } from "./host-api.js";
 import { createRouter, Telemetry } from "./router.js";
+import { BrainStatusPublisher } from "./status-events.js";
 import { Supervisor } from "./supervisor.js";
 import * as tailscale from "./tailscale.js";
 import { CertManager, resolveTlsOptions } from "./tls.js";
 import { removePidFile, writePidFile } from "./pid-lock.js";
+import { createBrainRunLog } from "./run-log.js";
 /** The effective config with secrets masked, for the `/__host/config` read. */
 function redactConfig(config) {
     return {
@@ -93,14 +95,15 @@ function withAuth(inner, token) {
     };
 }
 export async function startService({ config, modelNeedle, env = process.env, onLog = () => { }, }) {
+    const runLog = createBrainRunLog(env);
+    const log = (line) => {
+        runLog.write(line);
+        onLog(line);
+    };
+    // The management API must be useful before any setup exists: the Brain page
+    // is where the owner downloads both a runtime and their first model. Keep the
+    // listener up without either; loadModel reports the missing prerequisite.
     const runtime = resolveRuntime(config, env);
-    if (!runtime) {
-        throw new CommandError({
-            code: "NO_RUNTIME",
-            message: "no llama.cpp runtime available",
-            details: "run `otto brain runtime install` to download one, or install LM Studio",
-        });
-    }
     const paths = resolveBrainPaths(env);
     const tlsOptions = await resolveTlsOptions(config, paths);
     // `listen.host: "tailscale"` binds the tailnet interface only (invisible to the
@@ -138,10 +141,22 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     // this, and every reader goes through a getter so nobody holds a stale array.
     let catalog = scanModels(config, env);
     const needle = modelNeedle ?? config.defaultModel ?? store.lastModelId ?? undefined;
-    const model = needle ? pickModel(catalog, needle) : pickAutoModel(catalog);
-    let profile = forModel(store, model, config.defaults);
+    let model = null;
+    if (catalog.length > 0) {
+        try {
+            model = needle ? pickModel(catalog, needle) : pickAutoModel(catalog);
+        }
+        catch (error) {
+            // A removed default or last-used model must not take the management
+            // service down. An explicit CLI selection remains an actionable error.
+            if (modelNeedle)
+                throw error;
+            log(`note: ${error instanceof Error ? error.message : "configured model is unavailable"}`);
+        }
+    }
+    let profile = model ? forModel(store, model, config.defaults) : null;
     const gpu = await queryGpu();
-    if (gpu) {
+    if (gpu && model && profile) {
         const fit = vram.fitToBudget({
             model,
             profile,
@@ -149,28 +164,39 @@ export async function startService({ config, modelNeedle, env = process.env, onL
             totalVramBytes: gpu.totalBytes,
         });
         if (!fit.adjusted && !fit.budget.fits) {
-            throw new CommandError({
-                code: "DOES_NOT_FIT",
-                message: `refusing to start: ${fit.reason}`,
-                details: "use a smaller quant, or run `otto brain calibrate` for a measured budget",
-            });
+            // Starting the host is what exposes the Library and model profile UI.
+            // An automatic startup candidate that cannot load must therefore leave
+            // the host alive and unloaded, not make the only recovery surface vanish.
+            log(`note: not loading ${model.displayName}: ${fit.reason ?? "does not fit in available VRAM"}`);
+            model = null;
+            profile = null;
+        }
+        else {
+            if (fit.adjusted && fit.reason)
+                log(`note: ${fit.reason}`);
+            profile = fit.profile;
         }
-        if (fit.adjusted && fit.reason)
-            onLog(`note: ${fit.reason}`);
-        profile = fit.profile;
     }
     const telemetry = new Telemetry();
     const supervisor = new Supervisor({ runtime });
     supervisor.on("log", (line) => {
+        runLog.write(line);
         if (/error|failed|warn/i.test(line))
             onLog(line);
     });
+    supervisor.on("crashed", (error) => runLog.write(`FATAL ${error}`));
     // Serialize model switches: the router queues request-driven switches, but the
     // config path (POST /__host/config) calls loadModel directly. Chaining here
     // guarantees two switches (e.g. a config write racing a request-driven switch)
     // can never overlap two supervisor.start() calls, whichever caller triggers them.
     let modelSwitchChain = Promise.resolve();
     const loadModelUnsafe = async (target) => {
+        // A runtime can be installed from the Library tab after this service starts.
+        // Resolve it at load time so the user does not have to restart the brain.
+        supervisor.runtime = resolveRuntime(config, env);
+        if (!supervisor.runtime) {
+            throw new Error("no llama.cpp runtime available; install one from the Library tab");
+        }
         const gpuInfo = await queryGpu();
         let fitProfile = forModel(store, target, config.defaults);
         if (gpuInfo) {
@@ -232,6 +258,11 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     // One CPU sampler for the lifetime of the service: it reports a busy fraction
     // between successive calls, so a fresh one per request would always return null.
     const cpuSampler = createCpuSampler();
+    // Constructed here, ahead of both consumers, because the router installs the
+    // snapshot builder into it and the management API serves it at
+    // /__host/events. One instance, so `capabilities.events` and the stream can
+    // never disagree about whether this brain publishes.
+    const statusEvents = new BrainStatusPublisher();
     const hostApi = createHostApi({
         supervisor,
         getCatalog: () => catalog,
@@ -258,11 +289,12 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         getAllowWrite: allowWrite,
         getModelsDir: () => managedModelsDir(config, env),
         sampleResources: () => sampleSystem(cpuSampler, { host: supervisor.host, port: supervisor.internalPort }),
+        statusEvents,
     });
     const handler = withAuth(createRouter({
         supervisor,
         telemetry,
-        logger: { warn: (m) => onLog(`WARN ${m}`) },
+        logger: { warn: (m) => log(`WARN ${m}`) },
         getCatalog: () => catalog,
         loadModel,
         version: resolveVersion(),
@@ -273,7 +305,10 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         applyConfigPatch,
         getAllowConfigWrite: allowWrite,
         hostApi,
-        getResources: () => sampleSystem(cpuSampler, { host: supervisor.host, port: supervisor.internalPort }),
+        // `buildCheapStatus` already samples `/slots`. Do not hit it a second
+        // time in parallel: the shared rate tracker needs one ordered timeline.
+        getResources: () => sampleSystem(cpuSampler),
+        statusEvents,
     }), authToken);
     // TLS terminates in-process when configured; otherwise plain HTTP. The cert
     // manager issues/generates the first keypair before we listen, and hot-swaps
@@ -300,9 +335,17 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         server.listen(port, bindHost, resolve);
     });
     certManager?.start();
-    await supervisor.start(model, profile);
-    store.lastModelId = model.id;
-    saveProfilesStore(store, paths);
+    if (model && profile && runtime) {
+        await supervisor.start(model, profile);
+        store.lastModelId = model.id;
+        saveProfilesStore(store, paths);
+    }
+    else if (!runtime) {
+        log("ready: no llama.cpp runtime installed; use the Library tab to download one");
+    }
+    else {
+        log("ready: no model installed; use the Library tab to download one");
+    }
     writePidFile({
         pid: process.pid,
         host: bindHost,
@@ -311,9 +354,15 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         secure: Boolean(tlsOptions),
         displayHost,
     }, env);
+    log(`ready: ${supervisor.model?.displayName ?? "no model loaded"} on ${bindHost}:${port}; run log ${runLog.path}`);
     const stop = async () => {
         certManager?.stop();
+        log("Brain service stopping");
+        // Before server.close(), which waits on open connections: a subscribed
+        // daemon holds an SSE response open indefinitely by design.
+        statusEvents.close();
         await supervisor.stop();
+        server.closeIdleConnections?.();
         await new Promise((resolve) => server.close(() => resolve()));
         removePidFile(env);
     };
@@ -322,7 +371,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         supervisor,
         host: bindHost,
         port,
-        model,
+        model: supervisor.model,
         secure: Boolean(tlsOptions),
         displayHost,
         stop,

package/dist/service/status-events.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The brain's authoritative status event source.
+ *
+ * The brain owns its own state, so it publishes it rather than being polled for
+ * it. One daemon subscribes over SSE (`GET /__host/events`) and fans the result
+ * out to every connected Otto client, replacing a per-client status poll that
+ * could never show a transition sooner than its own interval.
+ *
+ * Three properties this has to keep:
+ *
+ *  - **Complete snapshots, never deltas.** A reader that missed an event, or
+ *    reconnected after one, must not have to reconstruct anything: the newest
+ *    snapshot is the whole truth. That is what makes reconnect repair on both
+ *    sides idempotent.
+ *  - **Coalescing lives here, not in the reader.** A timer tick that finds
+ *    nothing changed emits nothing, and a completion's traffic counters are not
+ *    a state change. Otherwise "push" would just be a poll with extra steps, and
+ *    a busy brain would broadcast to every client for every token.
+ *  - **No work while nobody is listening.** The sampler only runs while a
+ *    subscriber is attached, so a brain the daemon never subscribed to (an older
+ *    daemon, or one that is not running) pays nothing.
+ *
+ * The snapshot itself is deliberately the *cheap* status: no `resources`, whose
+ * collection spawns `nvidia-smi`. That stays an opt-in pull for the Overview tab.
+ */
+/** A complete cheap `/__host/status` body. Opaque here; the router assembles it. */
+export type BrainStatusSnapshot = Record<string, unknown>;
+export type BrainStatusListener = (snapshot: BrainStatusSnapshot) => void;
+/**
+ * The fields whose change is worth waking every connected client for.
+ *
+ * Everything omitted here still rides in the payload; it just cannot *trigger*
+ * a payload on its own. The omissions are the churning ones:
+ *
+ *  - `telemetry` totals and `recent` advance on every completion.
+ *  - `logLineCount` advances on every llama-server log line.
+ *  - `slots.contexts` is capacity detail that changes independently of work.
+ *
+ * `slots.threads` is intentionally included. It is sampled at a bounded 4 Hz,
+ * not notified per model token, so it gives the Overview live counts and rates
+ * without turning a fast model into a token-rate broadcast.
+ *
+ * `telemetry.warning` is kept: the reasoning-only advice is a state the UI
+ * shows, not a counter.
+ */
+export declare function statusChangeKey(snapshot: BrainStatusSnapshot): string;
+export interface BrainStatusPublisherOptions {
+    /** Resample cadence while subscribed. See DEFAULT_SAMPLE_INTERVAL_MS. */
+    sampleIntervalMs?: number;
+}
+/**
+ * Owns the current snapshot and decides when it changed.
+ *
+ * Constructed before the router (so `serve.ts` can hand the same instance to
+ * both the router and the management API) and inert until the router installs
+ * the snapshot source with {@link setSource}. `/__host/capabilities` advertises
+ * `events` only once it is {@link ready}, so a brain can never claim a stream it
+ * cannot actually serve.
+ */
+export declare class BrainStatusPublisher {
+    #private;
+    constructor(options?: BrainStatusPublisherOptions);
+    /** Whether a snapshot source has been installed - i.e. events can be served. */
+    get ready(): boolean;
+    get listenerCount(): number;
+    /** Install the snapshot builder. Called once, by the router. */
+    setSource(source: () => Promise<BrainStatusSnapshot>): void;
+    /**
+     * Attach a listener. It receives the current snapshot immediately when one is
+     * known, and a fresh sample is taken right away so a subscriber that arrives
+     * during a transition is not handed a stale first frame.
+     */
+    subscribe(listener: BrainStatusListener, onClose?: () => void): () => void;
+    /**
+     * Something authoritative changed - resample now rather than at the next tick.
+     * Cheap to over-call: an unchanged snapshot emits nothing.
+     */
+    notify(): void;
+    /**
+     * Drop every listener and end the streams behind them.
+     *
+     * Ending them is not optional at shutdown: an open SSE response is an open
+     * connection, and `server.close()` waits for those, so a brain that only
+     * unsubscribed would hang on stop until its daemon happened to disconnect.
+     */
+    close(): void;
+}
+//# sourceMappingURL=status-events.d.ts.map

package/dist/service/status-events.js

@@ -0,0 +1,256 @@
+/**
+ * The brain's authoritative status event source.
+ *
+ * The brain owns its own state, so it publishes it rather than being polled for
+ * it. One daemon subscribes over SSE (`GET /__host/events`) and fans the result
+ * out to every connected Otto client, replacing a per-client status poll that
+ * could never show a transition sooner than its own interval.
+ *
+ * Three properties this has to keep:
+ *
+ *  - **Complete snapshots, never deltas.** A reader that missed an event, or
+ *    reconnected after one, must not have to reconstruct anything: the newest
+ *    snapshot is the whole truth. That is what makes reconnect repair on both
+ *    sides idempotent.
+ *  - **Coalescing lives here, not in the reader.** A timer tick that finds
+ *    nothing changed emits nothing, and a completion's traffic counters are not
+ *    a state change. Otherwise "push" would just be a poll with extra steps, and
+ *    a busy brain would broadcast to every client for every token.
+ *  - **No work while nobody is listening.** The sampler only runs while a
+ *    subscriber is attached, so a brain the daemon never subscribed to (an older
+ *    daemon, or one that is not running) pays nothing.
+ *
+ * The snapshot itself is deliberately the *cheap* status: no `resources`, whose
+ * collection spawns `nvidia-smi`. That stays an opt-in pull for the Overview tab.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BrainStatusPublisher_instances, _BrainStatusPublisher_listeners, _BrainStatusPublisher_closers, _BrainStatusPublisher_sampleIntervalMs, _BrainStatusPublisher_source, _BrainStatusPublisher_timer, _BrainStatusPublisher_last, _BrainStatusPublisher_lastKey, _BrainStatusPublisher_sampling, _BrainStatusPublisher_resample, _BrainStatusPublisher_closed, _BrainStatusPublisher_sample, _BrainStatusPublisher_startTimer, _BrainStatusPublisher_stopTimer;
+/**
+ * How often the publisher resamples while at least one listener is attached.
+ *
+ * A sample is needed at all because two inputs have no event to hang off:
+ * `activity` is a file written by a *different* process (a `calibrate` or
+ * `pull` CLI run), and the slot phase split is a loopback read of
+ * llama-server's `/slots`. Everything else notifies directly. Sampling is not
+ * a heartbeat: an unchanged sample emits nothing.
+ */
+const DEFAULT_SAMPLE_INTERVAL_MS = 250;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * The fields whose change is worth waking every connected client for.
+ *
+ * Everything omitted here still rides in the payload; it just cannot *trigger*
+ * a payload on its own. The omissions are the churning ones:
+ *
+ *  - `telemetry` totals and `recent` advance on every completion.
+ *  - `logLineCount` advances on every llama-server log line.
+ *  - `slots.contexts` is capacity detail that changes independently of work.
+ *
+ * `slots.threads` is intentionally included. It is sampled at a bounded 4 Hz,
+ * not notified per model token, so it gives the Overview live counts and rates
+ * without turning a fast model into a token-rate broadcast.
+ *
+ * `telemetry.warning` is kept: the reasoning-only advice is a state the UI
+ * shows, not a counter.
+ */
+export function statusChangeKey(snapshot) {
+    const scheduler = isRecord(snapshot.scheduler) ? snapshot.scheduler : null;
+    const telemetry = isRecord(snapshot.telemetry) ? snapshot.telemetry : null;
+    const slots = isRecord(snapshot.slots) ? snapshot.slots : null;
+    return JSON.stringify({
+        version: snapshot.version ?? null,
+        apiVersion: snapshot.apiVersion ?? null,
+        state: snapshot.state ?? null,
+        model: snapshot.model ?? null,
+        modelId: snapshot.modelId ?? null,
+        pid: snapshot.pid ?? null,
+        vramBytes: snapshot.vramBytes ?? null,
+        loadSeconds: snapshot.loadSeconds ?? null,
+        startedAt: snapshot.startedAt ?? null,
+        lastError: snapshot.lastError ?? null,
+        upstream: snapshot.upstream ?? null,
+        runtime: snapshot.runtime ?? null,
+        capabilities: snapshot.capabilities ?? null,
+        activity: snapshot.activity ?? null,
+        reasoning: snapshot.reasoning ?? null,
+        inference: snapshot.inference ?? null,
+        queued: snapshot.queued ?? null,
+        schedulerWaiting: scheduler?.waiting ?? null,
+        schedulerLastTurn: scheduler?.lastTurn ?? null,
+        warning: telemetry?.warning ?? null,
+        slots: slots
+            ? {
+                total: slots.total ?? null,
+                busy: slots.busy ?? null,
+                idle: slots.idle ?? null,
+                prefill: slots.prefill ?? null,
+                decode: slots.decode ?? null,
+                threads: slots.threads ?? null,
+            }
+            : null,
+    });
+}
+/**
+ * Owns the current snapshot and decides when it changed.
+ *
+ * Constructed before the router (so `serve.ts` can hand the same instance to
+ * both the router and the management API) and inert until the router installs
+ * the snapshot source with {@link setSource}. `/__host/capabilities` advertises
+ * `events` only once it is {@link ready}, so a brain can never claim a stream it
+ * cannot actually serve.
+ */
+export class BrainStatusPublisher {
+    constructor(options = {}) {
+        _BrainStatusPublisher_instances.add(this);
+        _BrainStatusPublisher_listeners.set(this, new Set());
+        /** Per-subscription teardown, so `close()` can end the responses it feeds. */
+        _BrainStatusPublisher_closers.set(this, new Set());
+        _BrainStatusPublisher_sampleIntervalMs.set(this, void 0);
+        _BrainStatusPublisher_source.set(this, null);
+        _BrainStatusPublisher_timer.set(this, null);
+        /** The last snapshot that was actually emitted, replayed to a late subscriber. */
+        _BrainStatusPublisher_last.set(this, null);
+        _BrainStatusPublisher_lastKey.set(this, null);
+        /** True while a sample is in flight, so overlapping triggers collapse into one. */
+        _BrainStatusPublisher_sampling.set(this, false);
+        /** A trigger that arrived mid-sample; runs exactly one more sample afterwards. */
+        _BrainStatusPublisher_resample.set(this, false);
+        _BrainStatusPublisher_closed.set(this, false);
+        __classPrivateFieldSet(this, _BrainStatusPublisher_sampleIntervalMs, options.sampleIntervalMs ?? DEFAULT_SAMPLE_INTERVAL_MS, "f");
+    }
+    /** Whether a snapshot source has been installed - i.e. events can be served. */
+    get ready() {
+        return __classPrivateFieldGet(this, _BrainStatusPublisher_source, "f") !== null && !__classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f");
+    }
+    get listenerCount() {
+        return __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").size;
+    }
+    /** Install the snapshot builder. Called once, by the router. */
+    setSource(source) {
+        __classPrivateFieldSet(this, _BrainStatusPublisher_source, source, "f");
+    }
+    /**
+     * Attach a listener. It receives the current snapshot immediately when one is
+     * known, and a fresh sample is taken right away so a subscriber that arrives
+     * during a transition is not handed a stale first frame.
+     */
+    subscribe(listener, onClose) {
+        if (__classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f")) {
+            onClose?.();
+            return () => { };
+        }
+        __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").add(listener);
+        if (onClose)
+            __classPrivateFieldGet(this, _BrainStatusPublisher_closers, "f").add(onClose);
+        if (__classPrivateFieldGet(this, _BrainStatusPublisher_last, "f"))
+            listener(__classPrivateFieldGet(this, _BrainStatusPublisher_last, "f"));
+        __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_startTimer).call(this);
+        this.notify();
+        return () => {
+            __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").delete(listener);
+            if (onClose)
+                __classPrivateFieldGet(this, _BrainStatusPublisher_closers, "f").delete(onClose);
+            if (__classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").size === 0)
+                __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_stopTimer).call(this);
+        };
+    }
+    /**
+     * Something authoritative changed - resample now rather than at the next tick.
+     * Cheap to over-call: an unchanged snapshot emits nothing.
+     */
+    notify() {
+        if (__classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f") || __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").size === 0)
+            return;
+        void __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_sample).call(this);
+    }
+    /**
+     * Drop every listener and end the streams behind them.
+     *
+     * Ending them is not optional at shutdown: an open SSE response is an open
+     * connection, and `server.close()` waits for those, so a brain that only
+     * unsubscribed would hang on stop until its daemon happened to disconnect.
+     */
+    close() {
+        if (__classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f"))
+            return;
+        __classPrivateFieldSet(this, _BrainStatusPublisher_closed, true, "f");
+        __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_stopTimer).call(this);
+        __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").clear();
+        const closers = [...__classPrivateFieldGet(this, _BrainStatusPublisher_closers, "f")];
+        __classPrivateFieldGet(this, _BrainStatusPublisher_closers, "f").clear();
+        for (const onClose of closers) {
+            try {
+                onClose();
+            }
+            catch {
+                // Shutdown must not be blocked by one stream failing to end.
+            }
+        }
+    }
+}
+_BrainStatusPublisher_listeners = new WeakMap(), _BrainStatusPublisher_closers = new WeakMap(), _BrainStatusPublisher_sampleIntervalMs = new WeakMap(), _BrainStatusPublisher_source = new WeakMap(), _BrainStatusPublisher_timer = new WeakMap(), _BrainStatusPublisher_last = new WeakMap(), _BrainStatusPublisher_lastKey = new WeakMap(), _BrainStatusPublisher_sampling = new WeakMap(), _BrainStatusPublisher_resample = new WeakMap(), _BrainStatusPublisher_closed = new WeakMap(), _BrainStatusPublisher_instances = new WeakSet(), _BrainStatusPublisher_sample = async function _BrainStatusPublisher_sample() {
+    const source = __classPrivateFieldGet(this, _BrainStatusPublisher_source, "f");
+    if (!source || __classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f"))
+        return;
+    if (__classPrivateFieldGet(this, _BrainStatusPublisher_sampling, "f")) {
+        __classPrivateFieldSet(this, _BrainStatusPublisher_resample, true, "f");
+        return;
+    }
+    __classPrivateFieldSet(this, _BrainStatusPublisher_sampling, true, "f");
+    try {
+        const snapshot = await source();
+        if (__classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f"))
+            return;
+        const key = statusChangeKey(snapshot);
+        // Always keep the newest body for replay, even when nothing significant
+        // changed: a late subscriber should not get last minute's counters.
+        __classPrivateFieldSet(this, _BrainStatusPublisher_last, snapshot, "f");
+        if (key === __classPrivateFieldGet(this, _BrainStatusPublisher_lastKey, "f"))
+            return;
+        __classPrivateFieldSet(this, _BrainStatusPublisher_lastKey, key, "f");
+        // Set iteration tolerates a listener unsubscribing mid-emit, which the
+        // SSE teardown does when a daemon disconnects during a snapshot.
+        for (const listener of __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f")) {
+            try {
+                listener(snapshot);
+            }
+            catch {
+                // A broken listener is that listener's problem; the others still get it.
+            }
+        }
+    }
+    catch {
+        // A failed sample is not a state change. The next tick tries again.
+    }
+    finally {
+        __classPrivateFieldSet(this, _BrainStatusPublisher_sampling, false, "f");
+        if (__classPrivateFieldGet(this, _BrainStatusPublisher_resample, "f")) {
+            __classPrivateFieldSet(this, _BrainStatusPublisher_resample, false, "f");
+            void __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_sample).call(this);
+        }
+    }
+}, _BrainStatusPublisher_startTimer = function _BrainStatusPublisher_startTimer() {
+    if (__classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f") || __classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f"))
+        return;
+    __classPrivateFieldSet(this, _BrainStatusPublisher_timer, setInterval(() => this.notify(), __classPrivateFieldGet(this, _BrainStatusPublisher_sampleIntervalMs, "f")), "f");
+    // Never hold the process open for status reporting alone.
+    __classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f").unref?.();
+}, _BrainStatusPublisher_stopTimer = function _BrainStatusPublisher_stopTimer() {
+    if (!__classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f"))
+        return;
+    clearInterval(__classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f"));
+    __classPrivateFieldSet(this, _BrainStatusPublisher_timer, null, "f");
+};
+//# sourceMappingURL=status-events.js.map

package/dist/service/supervisor.d.ts

@@ -15,7 +15,7 @@ import type { Profile } from "../config/schema.js";
 export declare const DEFAULT_INTERNAL_PORT = 20800;
 export type SupervisorState = "stopped" | "starting" | "ready" | "failed" | "stopping";
 export interface SupervisorOptions {
-    runtime: Runtime;
+    runtime: Runtime | null;
     internalPort?: number;
     host?: string;
     readyTimeoutMs?: number;
@@ -40,7 +40,7 @@ export interface SupervisorStatus {
  */
 export declare class Supervisor extends EventEmitter {
     #private;
-    runtime: Runtime;
+    runtime: Runtime | null;
     internalPort: number;
     host: string;
     readyTimeoutMs: number;

package/dist/service/supervisor.js

@@ -54,6 +54,12 @@ export class Supervisor extends EventEmitter {
     /** Start (or restart) the server for a model + profile. */
     async start(model, profile) {
         await this.stop();
+        if (!this.runtime) {
+            this.lastError = "no llama.cpp runtime available";
+            __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "failed", this.lastError);
+            throw new Error(this.lastError);
+        }
+        const runtime = this.runtime;
         this.model = model;
         this.profile = profile;
         this.lastError = null;
@@ -62,12 +68,12 @@ export class Supervisor extends EventEmitter {
         __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 });
         this.args = args;
-        this.command = formatCommand(this.runtime, args);
+        this.command = formatCommand(runtime, args);
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, `launching: ${this.command}`);
         const started = Date.now();
-        this.child = spawn(this.runtime.exe, args, {
-            cwd: this.runtime.dir,
-            env: buildEnv(this.runtime),
+        this.child = spawn(runtime.exe, args, {
+            cwd: runtime.dir,
+            env: buildEnv(runtime),
             windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -194,7 +200,7 @@ export class Supervisor extends EventEmitter {
             startedAt: this.startedAt ? this.startedAt.toISOString() : null,
             lastError: this.lastError,
             upstream: this.upstreamBase,
-            runtime: `${this.runtime.label} v${this.runtime.version}`,
+            runtime: this.runtime ? `${this.runtime.label} v${this.runtime.version}` : "not installed",
         };
     }
 }

package/dist/sysmon.d.ts

@@ -31,6 +31,14 @@ export interface SlotInfo {
     /** Slots emitting tokens. */
     decode: number;
     contexts: number[];
+    threads?: Array<{
+        slot: number;
+        phase: "prefill" | "decode";
+        promptTokens: number | null;
+        generatedTokens: number;
+        promptTokensPerSecond: number | null;
+        tokensPerSecond: number | null;
+    }>;
 }
 /** One combined reading for the status panel. */
 export interface SystemSample {
@@ -55,6 +63,11 @@ export declare function createCpuSampler(): CpuSampler;
  * the field spellings real llama.cpp builds emit, without a live server.
  */
 export declare function summariseSlots(rows: unknown[]): SlotInfo;
+/** Measures throughput from successive `/slots` snapshots, without guessing. */
+export declare class SlotActivityTracker {
+    #private;
+    sample(rows: unknown[], now?: number): SlotInfo;
+}
 /** Slot occupancy from the running server. */
 declare function slots({ host, port }: {
     host: string;