@otto-code/brain 0.8.2 → 0.8.3

package/dist/service/router.js

@@ -5,6 +5,7 @@ import { slots as sampleSlots } from "../sysmon.js";
 import { makeVramFitPredicate, selectCodingModel } from "./model-selector.js";
 import { query as queryGpu } from "../gpu.js";
 import { rankModels } from "../ops/results.js";
+import { HOST_API_VERSION } from "./host-api.js";
 import { errorBody, errorMessage, HOP_BY_HOP, readJsonBody, sendError, sendJson, } from "./http-util.js";
 /**
  * Fronts the supervised llama-server on a stable port.
@@ -144,8 +145,10 @@ export function describeModel(model, options = {}) {
     const { state = "not-loaded", profile = null, createdAt = null } = options;
     const md = model.metadata || {};
     const entry = {
-        // Standard OpenAI fields - id is the friendly name, never the file path.
-        id: model.displayName,
+        // Keep the stable model key separate from Brain's editable display name.
+        // OpenAI-compatible clients send `id`; Otto uses `name` for presentation.
+        id: model.id,
+        name: model.displayName,
         object: "model",
         created: Math.floor((createdAt ? createdAt.getTime() : Date.now()) / 1000),
         owned_by: model.publisher || "local",
@@ -157,7 +160,13 @@ export function describeModel(model, options = {}) {
         quantization: model.quant || null,
         state,
         max_context_length: md.contextLength ?? null,
+        reasoning: Boolean(md.reasoning ?? model.thinking),
     };
+    const reasoningEfforts = md["reasoning_efforts"];
+    if (Array.isArray(reasoningEfforts) &&
+        reasoningEfforts.every((value) => typeof value === "string")) {
+        entry.reasoning_efforts = reasoningEfforts;
+    }
     if (state === "loaded" && profile && profile.contextSize) {
         // llama-server splits -c across --parallel slots, so the window a single
         // request actually gets is the total divided by the concurrency.
@@ -387,6 +396,10 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, r
             sendError(res, 502, `Upstream llama-server error: ${error.message}`);
             done();
         });
+        // This is the first authoritative inference-stage signal: the request is
+        // being dispatched to llama-server and is waiting for prompt processing or
+        // its first output delta.
+        reasoning?.begin(streamId);
         upstream.end(body);
     });
 }
@@ -477,10 +490,15 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
 // (rare), so the router caches the ranking and re-reads it at most once per
 // window - the cheap time-based trigger.
 const RANKING_TTL_MS = 60000;
-export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, }) {
+export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, statusEvents = null, }) {
     const agent = new http.Agent({ keepAlive: true, maxSockets: 32 });
     const scheduler = loadModel
-        ? new Scheduler({ supervisor, loadModel, logger: (m) => logger?.warn?.(m) })
+        ? new Scheduler({
+            supervisor,
+            loadModel,
+            logger: (m) => logger?.warn?.(m),
+            onChange: statusEvents ? () => statusEvents.notify() : null,
+        })
         : null;
     // A (re)start means whatever produced the current warning no longer applies -
     // either a different model is now resident, or the same one just picked up an
@@ -566,51 +584,79 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
             resolved: lock ? null : resolveModel(name),
         });
     };
+    /**
+     * The cheap host status: everything `/__host/status` answers except the
+     * opt-in `resources` block.
+     *
+     * One assembly feeds both the pull (`/__host/status`) and the push
+     * (`/__host/events`). Keeping them as one function is the point: a field that
+     * only the polled answer carried would be a field the rail silently lost the
+     * moment a daemon stopped polling.
+     */
+    const buildCheapStatus = async () => {
+        const schedulerStats = scheduler ? scheduler.stats() : null;
+        // Slots come from a loopback GET on the resident llama-server. That is
+        // cheap enough to pay on every sample - unlike GPU sampling, which spawns
+        // `nvidia-smi` and stays opt-in. Skipped entirely unless a model is
+        // resident, since there is nothing listening otherwise.
+        const slots = supervisor.state === "ready"
+            ? await sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
+            : null;
+        return {
+            version,
+            // Additive, and separate from `version`: the package version says which
+            // build this is, this says which generation of the management contract it
+            // speaks. A daemon reads this and `capabilities` rather than pinning a
+            // package version.
+            apiVersion: HOST_API_VERSION,
+            ...supervisor.status(),
+            telemetry: { ...telemetry.totals, warning: telemetry.warning },
+            scheduler: schedulerStats,
+            recent: telemetry.records.slice(-10),
+            logLineCount: supervisor.logLines.length,
+            // Carried inline rather than fetched from /__host/capabilities: the
+            // daemon reads status constantly, and a separately cached copy would go
+            // stale the moment the owner toggles allowRemoteConfig.
+            capabilities: hostApi ? hostApi.capabilities() : null,
+            // The three signals the Brain rail's icon is derived from. All are cheap
+            // enough for the liveness path: `activity` is one stat of a file that is
+            // usually absent, `reasoning` is in-process state, and `queued` is
+            // already computed above.
+            activity: readActivity(),
+            reasoning: reasoningTracker.active,
+            // Exact aggregate request stages from the proxy lifecycle. Unlike slot
+            // phase sampling, this distinguishes silent prompt processing, reasoning
+            // deltas and user-visible content even when several requests overlap.
+            inference: reasoningTracker.snapshot,
+            queued: schedulerStats ? schedulerStats.queued : 0,
+            slots,
+        };
+    };
+    // Publish rather than be polled. The publisher decides what counts as a
+    // change (see status-events.ts); everything here just says "look again".
+    if (statusEvents) {
+        statusEvents.setSource(buildCheapStatus);
+        supervisor.on("state", () => statusEvents.notify());
+        supervisor.on("crashed", () => statusEvents.notify());
+        reasoningTracker.onChange(() => statusEvents.notify());
+    }
     return function handler(req, res) {
         // Host-management read surface (`/__host/*`): the single API both the TUI and
         // Otto's GUI consume, so the two never drift. Status is live; config and
         // evals are point-in-time reads the daemon proxies to its settings UI.
         const path = (req.url || "").split("?")[0];
         if (path === "/__host/status") {
-            const schedulerStats = scheduler ? scheduler.stats() : null;
-            const base = {
-                version,
-                ...supervisor.status(),
-                telemetry: { ...telemetry.totals, warning: telemetry.warning },
-                scheduler: schedulerStats,
-                recent: telemetry.records.slice(-10),
-                logLineCount: supervisor.logLines.length,
-                // Carried inline rather than fetched from /__host/capabilities: the
-                // daemon polls status constantly, and a separately cached copy would go
-                // stale the moment the owner toggles allowRemoteConfig.
-                capabilities: hostApi ? hostApi.capabilities() : null,
-                // The three signals the Brain rail's icon is derived from. All are cheap
-                // enough for the liveness poll: `activity` is one stat of a file that is
-                // usually absent, `reasoning` is in-process state, and `queued` is
-                // already computed above. Slot phases are the one that costs a round
-                // trip, and are fetched below.
-                activity: readActivity(),
-                reasoning: reasoningTracker.active,
-                queued: schedulerStats ? schedulerStats.queued : 0,
-            };
-            // Slots come from a loopback GET on the resident llama-server. That is
-            // cheap enough to pay on every poll - unlike the GPU sampling below, which
-            // spawns `nvidia-smi` and stays opt-in. Skipped entirely unless a model is
-            // resident, since there is nothing listening otherwise.
-            const slotsPromise = supervisor.state === "ready"
-                ? sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
-                : Promise.resolve(null);
-            // Resources cost an `nvidia-smi` spawn, so they are opt-in: the daemon's
-            // liveness probe polls this route far more often than any UI does, and
-            // must not pay for a panel it is not rendering.
+            // Resources cost an `nvidia-smi` spawn, so they are opt-in: the daemon
+            // reads this route far more often than any UI does, and must not pay for
+            // a panel it is not rendering.
             const wantsResources = /[?&]resources=1(&|$)/.test(req.url || "");
             if (!wantsResources || !getResources) {
-                void slotsPromise.then((slots) => sendJson(res, { ...base, slots }));
+                void buildCheapStatus().then((base) => sendJson(res, base));
                 return;
             }
-            Promise.all([slotsPromise, getResources().catch(() => null)])
-                .then(([slots, resources]) => sendJson(res, { ...base, slots, resources }))
-                .catch(() => sendJson(res, { ...base, slots: null, resources: null }));
+            Promise.all([buildCheapStatus(), getResources().catch(() => null)])
+                .then(([base, resources]) => sendJson(res, { ...base, resources }))
+                .catch((error) => sendError(res, 500, `could not build the host status: ${errorMessage(error)}`));
             return;
         }
         // Config write: apply an editable patch (model/lock live, the rest persisted).

package/dist/service/scheduler.d.ts

@@ -33,6 +33,13 @@ export interface SchedulerOptions {
     supervisor: SchedulerSupervisor;
     loadModel: (model: Model) => Promise<void>;
     logger?: ((message: string) => void) | null;
+    /**
+     * Called whenever the queue depth or the turn changes - i.e. whenever
+     * `stats()` would answer differently. The status event stream publishes from
+     * this instead of sampling, so "queued behind a model switch" reaches the UI
+     * the moment it becomes true rather than up to a poll later.
+     */
+    onChange?: (() => void) | null;
 }
 /** A queued completion request bound to a resolved catalog model. */
 export interface QueuedJob {
@@ -55,7 +62,8 @@ export declare class Scheduler {
     queue: QueuedJob[];
     lastTurnId: string | null;
     pumping: boolean;
-    constructor({ supervisor, loadModel, logger }: SchedulerOptions);
+    onChange: (() => void) | null;
+    constructor({ supervisor, loadModel, logger, onChange }: SchedulerOptions);
     /** Id of the model that is actually loaded and ready, or null. */
     get loadedId(): string | null;
     /** How many requests may run at once against the resident model. */

package/dist/service/scheduler.js

@@ -3,10 +3,10 @@ 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 _Scheduler_instances, _Scheduler_take, _Scheduler_serveTurn;
+var _Scheduler_instances, _Scheduler_announce, _Scheduler_take, _Scheduler_serveTurn;
 const MAX_CONCURRENCY = 16;
 export class Scheduler {
-    constructor({ supervisor, loadModel, logger = null }) {
+    constructor({ supervisor, loadModel, logger = null, onChange = null }) {
         _Scheduler_instances.add(this);
         this.supervisor = supervisor;
         this.loadModel = loadModel; // async (model) => resolves once it is ready
@@ -14,6 +14,7 @@ export class Scheduler {
         this.queue = []; // { modelId, model, run, resolve, reject }
         this.lastTurnId = null;
         this.pumping = false;
+        this.onChange = onChange;
     }
     /** Id of the model that is actually loaded and ready, or null. */
     get loadedId() {
@@ -34,6 +35,7 @@ export class Scheduler {
     submit(model, run) {
         return new Promise((resolve, reject) => {
             this.queue.push({ modelId: model.id, model, run, resolve, reject });
+            __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
             queueMicrotask(() => this.pump());
         });
     }
@@ -61,6 +63,7 @@ export class Scheduler {
                     }
                 }
                 this.lastTurnId = turnId;
+                __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
                 await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_serveTurn).call(this, turnId);
             }
         }
@@ -78,12 +81,21 @@ export class Scheduler {
         return { queued: this.queue.length, waiting, lastTurn: this.lastTurnId };
     }
 }
-_Scheduler_instances = new WeakSet(), _Scheduler_take = function _Scheduler_take(pred) {
+_Scheduler_instances = new WeakSet(), _Scheduler_announce = function _Scheduler_announce() {
+    try {
+        this.onChange?.();
+    }
+    catch {
+        // Status reporting is not allowed to fail a queued completion.
+    }
+}, _Scheduler_take = function _Scheduler_take(pred) {
     const kept = [];
     const taken = [];
     for (const job of this.queue)
         (pred(job) ? taken : kept).push(job);
     this.queue = kept;
+    if (taken.length > 0)
+        __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
     return taken;
 }, _Scheduler_serveTurn = 
 /** Serve one model's snapshot with bounded concurrency. */

package/dist/service/serve.d.ts

@@ -37,7 +37,8 @@ export interface ServiceHandle {
     supervisor: Supervisor;
     host: string;
     port: number;
-    model: Model;
+    /** The model loaded during startup, if one was available. */
+    model: Model | null;
     /** Whether the listener terminates TLS (config.tls.mode !== "off"). */
     secure: boolean;
     /** The address to show a user: the MagicDNS/cert hostname when TLS is on, else the bind host. */

package/dist/service/serve.js

@@ -23,6 +23,7 @@ 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";
@@ -99,14 +100,10 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         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
@@ -144,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,
@@ -155,15 +164,18 @@ 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)
-            log(`note: ${fit.reason}`);
-        profile = fit.profile;
     }
     const telemetry = new Telemetry();
     const supervisor = new Supervisor({ runtime });
@@ -179,6 +191,12 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     // 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) {
@@ -240,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,
@@ -266,6 +289,7 @@ 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,
@@ -281,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
@@ -308,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,
@@ -319,11 +354,15 @@ export async function startService({ config, modelNeedle, env = process.env, onL
         secure: Boolean(tlsOptions),
         displayHost,
     }, env);
-    log(`ready: ${model.displayName} on ${bindHost}:${port}; run log ${runLog.path}`);
+    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);
     };
@@ -332,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