@otto-code/brain 0.8.10 → 0.8.12

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

@@ -26,6 +26,7 @@
 /** A complete cheap `/__host/status` body. Opaque here; the router assembles it. */
 export type BrainStatusSnapshot = Record<string, unknown>;
 export type BrainStatusListener = (snapshot: BrainStatusSnapshot) => void;
+export type BrainLogListener = (line: string) => void;
 /**
  * The fields whose change is worth waking every connected client for.
  *
@@ -45,8 +46,10 @@ export type BrainStatusListener = (snapshot: BrainStatusSnapshot) => void;
  */
 export declare function statusChangeKey(snapshot: BrainStatusSnapshot): string;
 export interface BrainStatusPublisherOptions {
-    /** Resample cadence while subscribed. See DEFAULT_SAMPLE_INTERVAL_MS. */
+    /** Resample cadence while work is in flight. See DEFAULT_SAMPLE_INTERVAL_MS. */
     sampleIntervalMs?: number;
+    /** Resample cadence while idle. See DEFAULT_IDLE_INTERVAL_MS. */
+    idleIntervalMs?: number;
 }
 /**
  * Owns the current snapshot and decides when it changed.
@@ -85,4 +88,14 @@ export declare class BrainStatusPublisher {
      */
     close(): void;
 }
+/**
+ * Pushes every completed Brain log line immediately. Unlike status snapshots,
+ * log lines are an ordered append-only stream, so coalescing would lose the
+ * exact evidence the Logs tab exists to show.
+ */
+export declare class BrainLogPublisher {
+    #private;
+    subscribe(listener: BrainLogListener): () => void;
+    publish(line: string): void;
+}
 //# sourceMappingURL=status-events.d.ts.map

package/dist/service/status-events.js

@@ -34,17 +34,39 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _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;
+var _BrainStatusPublisher_instances, _BrainStatusPublisher_listeners, _BrainStatusPublisher_closers, _BrainStatusPublisher_sampleIntervalMs, _BrainStatusPublisher_idleIntervalMs, _BrainStatusPublisher_source, _BrainStatusPublisher_timer, _BrainStatusPublisher_timerDelayMs, _BrainStatusPublisher_last, _BrainStatusPublisher_lastKey, _BrainStatusPublisher_sampling, _BrainStatusPublisher_resample, _BrainStatusPublisher_closed, _BrainStatusPublisher_sample, _BrainStatusPublisher_armTimer, _BrainStatusPublisher_stopTimer, _BrainLogPublisher_listeners;
 /**
- * How often the publisher resamples while at least one listener is attached.
+ * How often the publisher resamples while work is actually in flight.
  *
- * A sample is needed at all because two inputs have no event to hang off:
+ * A sample is needed at all because only 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.
+ * `pull` CLI run), and the per-slot token rates are a loopback read of
+ * llama-server's `/slots`. **Everything a user reads as state already arrives
+ * by push** - stage transitions call `notify()` through
+ * `reasoningTracker.onChange`, the scheduler through `onChange`, the supervisor
+ * on `state` and `crashed`. So this timer is not what makes the UI feel live;
+ * it only refreshes two numbers.
+ *
+ * It used to be 250ms (4 Hz), which cost a loopback GET to llama-server four
+ * times a second for the entire time a daemon was subscribed - including while
+ * the brain sat completely idle. `/slots` is served off llama-server's own task
+ * queue, so that traffic competes with the decoding it is reporting on, and the
+ * brain is already the heaviest thing on the machine. One second is well inside
+ * what a rounded tok/s readout can show (the rate is held between samples, see
+ * `SlotActivityTracker`), and it cuts the busy-path sampling by 4x.
+ */
+const DEFAULT_SAMPLE_INTERVAL_MS = 1000;
+/**
+ * How often to resample when nothing is running.
+ *
+ * With no request in flight, no queued job and no operation, the only thing a
+ * sample can discover is a `calibrate`/`pull` starting in another process -
+ * long jobs whose progress bar is not harmed by appearing a few seconds in.
+ * Everything else that could change is pushed. Polling an idle engine four
+ * times a second was pure waste: 14,400 loopback requests an hour to report
+ * that nothing happened.
  */
-const DEFAULT_SAMPLE_INTERVAL_MS = 250;
+const DEFAULT_IDLE_INTERVAL_MS = 5000;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -102,6 +124,39 @@ export function statusChangeKey(snapshot) {
             : null,
     });
 }
+/**
+ * Whether the last snapshot showed anything worth sampling quickly for.
+ *
+ * Read from the snapshot itself rather than tracked separately, so the cadence
+ * can never disagree with what was last published. Busy means one of:
+ * a request is dispatched or queued (the per-slot rates are moving), an
+ * operation is running (`activity` carries a progress bar), or the engine is
+ * between states (`ready` is the only settled one that serves traffic).
+ *
+ * Erring towards "busy" is the safe direction - it costs a sample, where the
+ * opposite would freeze a moving number - so an unreadable snapshot counts as
+ * busy.
+ */
+function isBusySnapshot(snapshot) {
+    if (snapshot.activity != null)
+        return true;
+    const queued = snapshot.queued;
+    if (typeof queued === "number" && queued > 0)
+        return true;
+    const inference = isRecord(snapshot.inference) ? snapshot.inference : null;
+    if (inference) {
+        for (const key of ["activeRequests", "processing", "thinking", "generating"]) {
+            const value = inference[key];
+            if (typeof value === "number" && value > 0)
+                return true;
+        }
+    }
+    const state = snapshot.state;
+    // A settled engine that is not serving anything: "ready" idles here, and
+    // "stopped" has no engine to poll at all. Anything else is mid-transition
+    // (starting, loading) and worth watching closely.
+    return typeof state === "string" && state !== "ready" && state !== "stopped";
+}
 /**
  * Owns the current snapshot and decides when it changed.
  *
@@ -118,8 +173,11 @@ export class BrainStatusPublisher {
         /** Per-subscription teardown, so `close()` can end the responses it feeds. */
         _BrainStatusPublisher_closers.set(this, new Set());
         _BrainStatusPublisher_sampleIntervalMs.set(this, void 0);
+        _BrainStatusPublisher_idleIntervalMs.set(this, void 0);
         _BrainStatusPublisher_source.set(this, null);
         _BrainStatusPublisher_timer.set(this, null);
+        /** The cadence the running timer was armed at, so it is only re-armed on change. */
+        _BrainStatusPublisher_timerDelayMs.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);
@@ -129,6 +187,10 @@ export class BrainStatusPublisher {
         _BrainStatusPublisher_resample.set(this, false);
         _BrainStatusPublisher_closed.set(this, false);
         __classPrivateFieldSet(this, _BrainStatusPublisher_sampleIntervalMs, options.sampleIntervalMs ?? DEFAULT_SAMPLE_INTERVAL_MS, "f");
+        // Never slower than the busy cadence: a caller that asks for a slow busy
+        // poll means "sample rarely", and an idle default below it would speed the
+        // idle path up instead.
+        __classPrivateFieldSet(this, _BrainStatusPublisher_idleIntervalMs, Math.max(options.idleIntervalMs ?? DEFAULT_IDLE_INTERVAL_MS, __classPrivateFieldGet(this, _BrainStatusPublisher_sampleIntervalMs, "f")), "f");
     }
     /** Whether a snapshot source has been installed - i.e. events can be served. */
     get ready() {
@@ -156,7 +218,10 @@ export class BrainStatusPublisher {
             __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);
+        // Start at the busy cadence; the sample below settles it. Guessing high for
+        // one tick costs a single loopback read, where guessing low could leave a
+        // subscriber that arrived mid-generation waiting out the idle interval.
+        __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_armTimer).call(this, __classPrivateFieldGet(this, _BrainStatusPublisher_sampleIntervalMs, "f"));
         this.notify();
         return () => {
             __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").delete(listener);
@@ -200,7 +265,7 @@ export class BrainStatusPublisher {
         }
     }
 }
-_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() {
+_BrainStatusPublisher_listeners = new WeakMap(), _BrainStatusPublisher_closers = new WeakMap(), _BrainStatusPublisher_sampleIntervalMs = new WeakMap(), _BrainStatusPublisher_idleIntervalMs = new WeakMap(), _BrainStatusPublisher_source = new WeakMap(), _BrainStatusPublisher_timer = new WeakMap(), _BrainStatusPublisher_timerDelayMs = 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;
@@ -217,6 +282,10 @@ _BrainStatusPublisher_listeners = new WeakMap(), _BrainStatusPublisher_closers =
         // 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");
+        // Re-pace from what was actually observed, before the unchanged-snapshot
+        // return below - an idle brain reports "nothing changed" every time, and
+        // that is exactly the case whose cadence needs to back off.
+        __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_armTimer).call(this, isBusySnapshot(snapshot) ? __classPrivateFieldGet(this, _BrainStatusPublisher_sampleIntervalMs, "f") : __classPrivateFieldGet(this, _BrainStatusPublisher_idleIntervalMs, "f"));
         if (key === __classPrivateFieldGet(this, _BrainStatusPublisher_lastKey, "f"))
             return;
         __classPrivateFieldSet(this, _BrainStatusPublisher_lastKey, key, "f");
@@ -241,10 +310,14 @@ _BrainStatusPublisher_listeners = new WeakMap(), _BrainStatusPublisher_closers =
             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"))
+}, _BrainStatusPublisher_armTimer = function _BrainStatusPublisher_armTimer(delayMs) {
+    if (__classPrivateFieldGet(this, _BrainStatusPublisher_closed, "f") || __classPrivateFieldGet(this, _BrainStatusPublisher_listeners, "f").size === 0)
+        return;
+    if (__classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f") && __classPrivateFieldGet(this, _BrainStatusPublisher_timerDelayMs, "f") === delayMs)
         return;
-    __classPrivateFieldSet(this, _BrainStatusPublisher_timer, setInterval(() => this.notify(), __classPrivateFieldGet(this, _BrainStatusPublisher_sampleIntervalMs, "f")), "f");
+    __classPrivateFieldGet(this, _BrainStatusPublisher_instances, "m", _BrainStatusPublisher_stopTimer).call(this);
+    __classPrivateFieldSet(this, _BrainStatusPublisher_timerDelayMs, delayMs, "f");
+    __classPrivateFieldSet(this, _BrainStatusPublisher_timer, setInterval(() => this.notify(), delayMs), "f");
     // Never hold the process open for status reporting alone.
     __classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f").unref?.();
 }, _BrainStatusPublisher_stopTimer = function _BrainStatusPublisher_stopTimer() {
@@ -252,5 +325,31 @@ _BrainStatusPublisher_listeners = new WeakMap(), _BrainStatusPublisher_closers =
         return;
     clearInterval(__classPrivateFieldGet(this, _BrainStatusPublisher_timer, "f"));
     __classPrivateFieldSet(this, _BrainStatusPublisher_timer, null, "f");
+    __classPrivateFieldSet(this, _BrainStatusPublisher_timerDelayMs, null, "f");
 };
+/**
+ * Pushes every completed Brain log line immediately. Unlike status snapshots,
+ * log lines are an ordered append-only stream, so coalescing would lose the
+ * exact evidence the Logs tab exists to show.
+ */
+export class BrainLogPublisher {
+    constructor() {
+        _BrainLogPublisher_listeners.set(this, new Set());
+    }
+    subscribe(listener) {
+        __classPrivateFieldGet(this, _BrainLogPublisher_listeners, "f").add(listener);
+        return () => __classPrivateFieldGet(this, _BrainLogPublisher_listeners, "f").delete(listener);
+    }
+    publish(line) {
+        for (const listener of __classPrivateFieldGet(this, _BrainLogPublisher_listeners, "f")) {
+            try {
+                listener(line);
+            }
+            catch {
+                // One dead client must not interrupt the service log.
+            }
+        }
+    }
+}
+_BrainLogPublisher_listeners = new WeakMap();
 //# sourceMappingURL=status-events.js.map

package/dist/service/supervisor.d.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from "node:events";
 import { type BrainPaths } from "../config/paths.js";
 import type { Model, Runtime } from "../types.js";
 import type { Profile, ProfilesStore } from "../config/schema.js";
+import { type BrainLogArea } from "./log-format.js";
 /**
  * Default loopback port for the private llama-server child. Deliberately clear
  * of Otto's space: 8081 (the old default) is the Expo/Metro dev port, so a brain
@@ -19,6 +20,7 @@ export interface SupervisorOptions {
     runtime: Runtime | null;
     internalPort?: number;
     host?: string;
+    logVerbosity?: number;
     readyTimeoutMs?: number;
     /**
      * Long-lived hosts provide their live store so profile edits applied just
@@ -52,6 +54,7 @@ export declare class Supervisor extends EventEmitter {
     runtime: Runtime | null;
     internalPort: number;
     host: string;
+    logVerbosity: number;
     readyTimeoutMs: number;
     paths: BrainPaths;
     getProfilesStore: () => ProfilesStore;
@@ -72,16 +75,17 @@ export declare class Supervisor extends EventEmitter {
      * shell line is for reading, not for re-parsing.
      */
     args: string[] | null;
-    constructor({ runtime, internalPort, host, readyTimeoutMs, paths, getProfilesStore, }: SupervisorOptions);
+    constructor({ runtime, internalPort, host, logVerbosity, readyTimeoutMs, paths, getProfilesStore, }: SupervisorOptions);
     get upstreamBase(): string;
     /**
-     * Add a host-operation event to the same bounded tail as llama-server output.
+     * Add a host-operation event to the same in-process tail as llama-server output.
      *
      * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
      * than creating invisible sidecar servers. Their lifecycle markers belong in
-     * the same log stream as the child they exercise.
+     * the same event stream as the child they exercise. The serving process
+     * copies that stream into its durable full Brain-session log.
      */
-    recordLog(line: string): void;
+    recordLog(line: string, area?: BrainLogArea): void;
     /**
      * Start (or restart) the server for a model + profile.
      *
@@ -90,9 +94,7 @@ export declare class Supervisor extends EventEmitter {
      * Jinja template and router-visible system addendum mandatory for every
      * caller, including future maintenance operations that start a sidecar.
      */
-    start(model: Model, profile: Profile, options?: {
-        preserveLogs?: boolean;
-    }): Promise<this>;
+    start(model: Model, profile: Profile): Promise<this>;
     /** Fetch /props from the running server (modalities, template caps, defaults). */
     props(): Promise<unknown>;
     stop(): Promise<void>;

package/dist/service/supervisor.js

@@ -5,14 +5,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _Supervisor_instances, _Supervisor_setState, _Supervisor_log, _Supervisor_health;
 import http from "node:http";
+import path from "node:path";
+import { mkdirSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { buildArgs, buildEnv, formatCommand } from "../runtime/index.js";
 import { resolveHostingProfileForLaunch } from "../config/hosting-profiles.js";
+import { getCalibration } from "../config/profiles.js";
 import { resolveBrainPaths } from "../config/paths.js";
 import { loadProfilesStore } from "../config/store.js";
 import { usedBytes } from "../gpu.js";
-const LOG_LINES_KEPT = 300;
+import { formatBrainLog, formatLlamaServerLog } from "./log-format.js";
+const LOG_LINES_KEPT = 10000;
 /**
  * Default loopback port for the private llama-server child. Deliberately clear
  * of Otto's space: 8081 (the old default) is the Expo/Metro dev port, so a brain
@@ -31,12 +35,13 @@ export const DEFAULT_INTERNAL_PORT = 20800;
  * stable one so switching models never asks a client to reconnect elsewhere.
  */
 export class Supervisor extends EventEmitter {
-    constructor({ runtime, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", readyTimeoutMs = 300000, paths = resolveBrainPaths(), getProfilesStore = loadProfilesStore, }) {
+    constructor({ runtime, internalPort = DEFAULT_INTERNAL_PORT, host = "127.0.0.1", logVerbosity = 3, readyTimeoutMs = 300000, paths = resolveBrainPaths(), getProfilesStore = loadProfilesStore, }) {
         super();
         _Supervisor_instances.add(this);
         this.runtime = runtime;
         this.internalPort = internalPort;
         this.host = host;
+        this.logVerbosity = logVerbosity;
         this.readyTimeoutMs = readyTimeoutMs;
         this.paths = paths;
         this.getProfilesStore = getProfilesStore;
@@ -57,14 +62,15 @@ export class Supervisor extends EventEmitter {
         return `http://${this.host}:${this.internalPort}`;
     }
     /**
-     * Add a host-operation event to the same bounded tail as llama-server output.
+     * Add a host-operation event to the same in-process tail as llama-server output.
      *
      * Calibrate, sweep, and benchmark deliberately reuse this supervisor rather
      * than creating invisible sidecar servers. Their lifecycle markers belong in
-     * the same log stream as the child they exercise.
+     * the same event stream as the child they exercise. The serving process
+     * copies that stream into its durable full Brain-session log.
      */
-    recordLog(line) {
-        __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, line);
+    recordLog(line, area = "model") {
+        __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, formatBrainLog(area, line));
     }
     /**
      * Start (or restart) the server for a model + profile.
@@ -74,7 +80,7 @@ export class Supervisor extends EventEmitter {
      * Jinja template and router-visible system addendum mandatory for every
      * caller, including future maintenance operations that start a sidecar.
      */
-    async start(model, profile, options = {}) {
+    async start(model, profile) {
         await this.stop();
         if (!this.runtime) {
             this.lastError = "no llama.cpp runtime available";
@@ -82,18 +88,37 @@ export class Supervisor extends EventEmitter {
             throw new Error(this.lastError);
         }
         const runtime = this.runtime;
+        // The engine's slot save/erase directory, under the brain's home so it
+        // survives across model relaunches (the dir is persistent; the engine only
+        // ever uses it for the `action=erase` the scheduler issues on a handoff,
+        // which never writes a file). Created before the args are built because
+        // llama.cpp validates it exists at launch and throws otherwise.
+        const slotSavePath = path.join(this.paths.root, "slot-saves");
+        try {
+            mkdirSync(slotSavePath, { recursive: true });
+        }
+        catch {
+            /* the engine then starts without slot actions - the pre-fix behavior */
+        }
         const launchProfile = resolveHostingProfileForLaunch(this.paths, this.getProfilesStore(), profile, model.family);
         this.model = model;
         this.profile = launchProfile;
         this.lastError = null;
-        if (!options.preserveLogs)
-            this.logLines = [];
         this.vramBaselineBytes = await usedBytes();
         __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_setState).call(this, "starting");
-        const args = buildArgs({ ...launchProfile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, { port: this.internalPort, host: this.host }, model);
+        const args = buildArgs({ ...launchProfile, modelPath: model.modelPath, mmprojPath: model.mmprojPath }, {
+            port: this.internalPort,
+            host: this.host,
+            logVerbosity: this.logVerbosity,
+            slotSavePath,
+        }, model, 
+        // The prompt-cache budget is derived from measured KV bytes/token, so the
+        // launch boundary is where it has to be resolved - nothing downstream of
+        // here can reach the calibration store.
+        getCalibration(this.getProfilesStore(), model, launchProfile));
         this.args = args;
         this.command = formatCommand(runtime, args);
-        __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, `launching: ${this.command}`);
+        __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, formatBrainLog("model", `launching: ${this.command}`));
         const started = Date.now();
         this.child = spawn(runtime.exe, args, {
             cwd: runtime.dir,
@@ -104,7 +129,7 @@ export class Supervisor extends EventEmitter {
         const onChunk = (chunk) => {
             for (const line of String(chunk).split(/\r?\n/)) {
                 if (line.trim())
-                    __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, line.trim());
+                    __classPrivateFieldGet(this, _Supervisor_instances, "m", _Supervisor_log).call(this, formatLlamaServerLog(line.trim()));
             }
         };
         this.child.stdout?.on("data", onChunk);

package/dist/sysmon.d.ts

@@ -31,6 +31,21 @@ export interface SlotInfo {
     /** Slots emitting tokens. */
     decode: number;
     contexts: number[];
+    /**
+     * The engine's ids for the slots that are NOT processing, in `/slots` order.
+     *
+     * `idle` counts them; this names them, which is the difference between
+     * knowing there is room and being able to pin a request to a specific slot
+     * (`id_slot`). The scheduler hands one of these to each job it admits so the
+     * proxy can attribute that request's stage to the exact slot row the Overview
+     * panel shows. Empty when every slot is busy - never a guess, because a
+     * guessed id would pin a request onto work that is already running.
+     *
+     * Deliberately the idle half, not the busy half: `threads` below lists only
+     * the slots that ARE processing, so it is the wrong end to draw a free slot
+     * from.
+     */
+    idleSlots: number[];
     threads?: Array<{
         slot: number;
         phase: "prefill" | "decode";

package/dist/sysmon.js

@@ -65,6 +65,17 @@ function isProcessing(rec) {
         return rec.state !== 0;
     return false;
 }
+/**
+ * The engine's id for a slot row, falling back to its position in `/slots`.
+ *
+ * Shared by the summary and the per-slot sampler so a slot cannot be called `2`
+ * in one and `1` in the other - the ids are used to join a request to a row, and
+ * a disagreement here would attribute a stage to the wrong slot.
+ */
+function slotIdOf(rec, index) {
+    const id = rec.id;
+    return typeof id === "number" && Number.isFinite(id) ? id : index;
+}
 /** How many tokens this slot has emitted for the request it is on. */
 function decodedTokens(rec) {
     for (const key of ["n_decoded", "n_decoded_tokens", "tokens_predicted"]) {
@@ -112,6 +123,9 @@ export function summariseSlots(rows) {
         idle: rows.length - busyRows.length,
         prefill,
         decode: busyRows.length - prefill,
+        idleSlots: rows.flatMap((s, index) => isProcessing(s)
+            ? []
+            : [slotIdOf(s, index)]),
         contexts: rows.map((s) => {
             const rec = s;
             const nCtx = typeof rec.n_ctx === "number" ? rec.n_ctx : undefined;
@@ -128,8 +142,7 @@ export class SlotActivityTracker {
     sample(rows, now = Date.now()) {
         const threads = rows.flatMap((row, index) => {
             const record = row;
-            const id = record.id;
-            const slot = typeof id === "number" && Number.isFinite(id) ? id : index;
+            const slot = slotIdOf(record, index);
             if (!isProcessing(record)) {
                 __classPrivateFieldGet(this, _SlotActivityTracker_previous, "f").delete(slot);
                 return [];
@@ -155,19 +168,53 @@ export class SlotActivityTracker {
                     : generatedTokens === 0
                         ? "prefill"
                         : "decode";
-            const elapsedSeconds = previous ? (now - previous.at) / 1000 : 0;
-            const rate = (current, before) => current !== null && elapsedSeconds > 0 && before != null && current >= before
-                ? (current - before) / elapsedSeconds
-                : null;
-            __classPrivateFieldGet(this, _SlotActivityTracker_previous, "f").set(slot, { at: now, task, promptTokens, generatedTokens, phase });
+            // Rate is measured against the last window in which this counter actually
+            // MOVED, not against the last poll. `/slots` is read at 4 Hz while both
+            // counters advance in chunks (prefill a whole batch at a time), so a chunk
+            // landing after several flat polls covers all of them: dividing it by the
+            // final 250 ms window alone would report several times the real speed.
+            // Holding the baseline until movement makes the number an average over the
+            // interval it was actually earned. A counter that has not moved yet still
+            // yields null - "no measurement", never a fabricated 0 tok/s.
+            const advance = (current, base) => {
+                if (current === null)
+                    return { rate: null, base: undefined };
+                if (!base)
+                    return { rate: null, base: { at: now, tokens: current } };
+                const seconds = (now - base.at) / 1000;
+                if (current <= base.tokens || seconds <= 0)
+                    return { rate: null, base };
+                return { rate: (current - base.tokens) / seconds, base: { at: now, tokens: current } };
+            };
+            const promptStep = advance(promptTokens, previous?.promptBase);
+            const decodeStep = advance(generatedTokens, previous?.decodeBase);
+            // A flat window is the counter not having moved *yet*, not throughput
+            // falling to nothing, so the last rate measured for THIS task carries
+            // forward instead of blanking the field. At any real speed most windows
+            // are flat, which is why the number used to visibly blink out and back on
+            // every poll. It cannot go stale across requests: `previous` is already
+            // gated on an unchanged `id_task`, and the row disappears entirely once
+            // the slot stops processing.
+            const promptRate = promptStep.rate ?? previous?.promptRate ?? null;
+            const decodeRate = decodeStep.rate ?? previous?.decodeRate ?? null;
+            __classPrivateFieldGet(this, _SlotActivityTracker_previous, "f").set(slot, {
+                task,
+                promptTokens,
+                generatedTokens,
+                phase,
+                promptBase: promptStep.base,
+                decodeBase: decodeStep.base,
+                promptRate,
+                decodeRate,
+            });
             return [
                 {
                     slot,
                     phase,
                     promptTokens,
                     generatedTokens,
-                    promptTokensPerSecond: phase === "prefill" ? rate(promptTokens, previous?.promptTokens) : null,
-                    tokensPerSecond: phase === "decode" ? rate(generatedTokens, previous?.generatedTokens) : null,
+                    promptTokensPerSecond: phase === "prefill" ? promptRate : null,
+                    tokensPerSecond: phase === "decode" ? decodeRate : null,
                 },
             ];
         });

package/dist/tui/app.d.ts

@@ -52,7 +52,13 @@ interface Field {
     step?: number;
     min?: number;
     max?: number | ((ctx: FieldContext) => number);
-    values?: Array<number | string>;
+    /**
+     * Cycle options as the values actually stored, not their labels: `adjust`
+     * writes the selected entry straight into the profile, so a list of display
+     * strings would persist "on" where the schema wants `true`. `format` is the
+     * one place that turns a stored value into something readable.
+     */
+    values?: Array<number | string | boolean | null>;
     note?: (profile: Profile) => string | null;
     enabled?: (ctx: FieldContext) => boolean;
 }
@@ -170,7 +176,7 @@ export declare class App {
     /** Read a profile field by key, without narrowing to a single value type. */
     readField(key: keyof Profile): unknown;
     /** Write a profile field by key; a no-op when no model is selected. */
-    writeField(key: keyof Profile, value: number | string | boolean): void;
+    writeField(key: keyof Profile, value: number | string | boolean | null): void;
     adjust(direction: number): void;
     activateField(): void;
     applyMaxContext(): void;