@otto-code/brain 0.7.6 → 0.8.0

package/dist/sysmon.d.ts

@@ -7,17 +7,29 @@ import { query } from "./gpu.js";
  * inferred from request counting, so it reflects what the engine is really
  * doing. That matters for agentic use: several concurrent requests are only
  * genuinely parallel if there are free slots to take them, and slots share one
- * KV pool — so more concurrency costs context per request.
+ * KV pool - so more concurrency costs context per request.
  */
 /** A CPU busy-fraction sampler: returns the fraction in [0,1], or null. */
 export interface CpuSampler {
     (): number | null;
 }
-/** Slot occupancy from the running server. */
+/**
+ * Slot occupancy from the running server.
+ *
+ * `busy` is the sum of `prefill` and `decode`. The split matters because the two
+ * phases feel completely different from outside: prefill is a single batched
+ * pass over the prompt that pins the GPU and returns nothing, decode is the
+ * token-at-a-time stream. A UI that can only say "busy" cannot tell a long
+ * prompt being ingested from a model that has started answering.
+ */
 export interface SlotInfo {
     total: number;
     busy: number;
     idle: number;
+    /** Slots ingesting a prompt: processing, but not a single token emitted yet. */
+    prefill: number;
+    /** Slots emitting tokens. */
+    decode: number;
     contexts: number[];
 }
 /** One combined reading for the status panel. */
@@ -37,9 +49,13 @@ interface Endpoint {
 /** CPU busy fraction, sampled between successive calls. */
 export declare function createCpuSampler(): CpuSampler;
 /**
- * Slot occupancy from the running server.
- * @returns {{total:number, busy:number, idle:number, contexts:number[]}|null}
+ * Reduce llama-server's `/slots` array to the occupancy the UI shows.
+ *
+ * Exported separately from the fetch so the phase split can be tested against
+ * the field spellings real llama.cpp builds emit, without a live server.
  */
+export declare function summariseSlots(rows: unknown[]): SlotInfo;
+/** Slot occupancy from the running server. */
 declare function slots({ host, port }: {
     host: string;
     port: number;

package/dist/sysmon.js

@@ -51,28 +51,45 @@ function fetchJson({ host, port, path: urlPath, timeout = 2500, }) {
         req.on("error", () => resolve(null));
     });
 }
+/** Whether a slot is doing anything. Field naming has varied across versions. */
+function isProcessing(rec) {
+    if (typeof rec.is_processing === "boolean")
+        return rec.is_processing;
+    if (typeof rec.state === "number")
+        return rec.state !== 0;
+    return false;
+}
+/** 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"]) {
+        const value = rec[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+    }
+    // No counter at all: report a non-zero so the slot lands in decode rather than
+    // claiming a prefill that may never have been happening.
+    return 1;
+}
 /**
- * Slot occupancy from the running server.
- * @returns {{total:number, busy:number, idle:number, contexts:number[]}|null}
+ * Reduce llama-server's `/slots` array to the occupancy the UI shows.
+ *
+ * Exported separately from the fetch so the phase split can be tested against
+ * the field spellings real llama.cpp builds emit, without a live server.
  */
-async function slots({ host, port }) {
-    const data = await fetchJson({ host, port, path: "/slots" });
-    if (!Array.isArray(data))
-        return null;
-    const rows = data;
-    // Field naming has varied across llama.cpp versions; accept either.
-    const busy = rows.filter((s) => {
-        const rec = s;
-        if (typeof rec.is_processing === "boolean")
-            return rec.is_processing;
-        if (typeof rec.state === "number")
-            return rec.state !== 0;
-        return false;
-    }).length;
+export function summariseSlots(rows) {
+    const busyRows = rows.filter((s) => isProcessing(s));
+    // A busy slot that has not yet decoded a token is still ingesting its prompt.
+    // The decoded counter is the only field that separates the two phases, and it
+    // has been spelled three ways across llama.cpp versions; a slot that reports
+    // none of them counts as decode, because a busy slot that cannot prove it is
+    // still prefilling is far more likely to be mid-answer than mid-prompt.
+    const prefill = busyRows.filter((s) => decodedTokens(s) === 0).length;
     return {
         total: rows.length,
-        busy,
-        idle: rows.length - busy,
+        busy: busyRows.length,
+        idle: rows.length - busyRows.length,
+        prefill,
+        decode: busyRows.length - prefill,
         contexts: rows.map((s) => {
             const rec = s;
             const nCtx = typeof rec.n_ctx === "number" ? rec.n_ctx : undefined;
@@ -81,6 +98,13 @@ async function slots({ host, port }) {
         }),
     };
 }
+/** Slot occupancy from the running server. */
+async function slots({ host, port }) {
+    const data = await fetchJson({ host, port, path: "/slots" });
+    if (!Array.isArray(data))
+        return null;
+    return summariseSlots(data);
+}
 export { slots };
 /** One combined reading for the status panel. */
 export async function sample(sampler, { host, port } = {}) {

package/dist/tui/app.d.ts

@@ -1,5 +1,6 @@
 import { Screen } from "./screen.js";
 import type { DiskUsage, QuantOption, RepoQuants, ModelSearchResult } from "../models/index.js";
+import * as vram from "../vram.js";
 import { Supervisor } from "../service/supervisor.js";
 import { Telemetry } from "../service/router.js";
 import http from "node:http";
@@ -103,6 +104,15 @@ export declare class App {
     telemetry: Telemetry;
     supervisor: Supervisor;
     routerServer: http.Server | null;
+    /**
+     * The VRAM fit behind the resident model, so a benchmark can record whether
+     * the profile it measured was the profile the user configured. Keyed by model
+     * id because a fit computed for one model says nothing about the next.
+     */
+    lastFit: {
+        modelId: string;
+        fit: vram.FitResult;
+    } | null;
     filterMode: boolean;
     confirming: ConfirmState | null;
     picker: PickerState | null;
@@ -199,8 +209,8 @@ export declare class App {
     drawHelp(cols: number): void;
     /**
      * The key hints for the current mode, as an array of lines. Groups are
-     * deliberately broken onto separate lines — navigation first, then the
-     * actions — and each group wraps further only if the terminal is too narrow.
+     * deliberately broken onto separate lines - navigation first, then the
+     * actions - and each group wraps further only if the terminal is too narrow.
      */
     keybindings(cols: number): string[];
 }

package/dist/tui/app.js

@@ -1,7 +1,7 @@
 import { Screen, box, meter, style, pad, truncate, width, onKeys } from "./screen.js";
 import { scanModels, managedModelsDir, diskUsage, totalModelBytes, planDelete, deleteModelFiles, listRepoQuants, searchModels, downloadRepoFiles, resolveHfToken, } from "../models/index.js";
 import * as profiles from "../config/profiles.js";
-import { loadBrainConfig, loadProfilesStore, saveProfilesStore } from "../config/index.js";
+import { formatReasoningBudget, loadBrainConfig, loadProfilesStore, saveProfilesStore, UNRESTRICTED_REASONING_BUDGET, } from "../config/index.js";
 import * as vram from "../vram.js";
 import * as gpu from "../gpu.js";
 import { calibrate } from "../ops/calibrate.js";
@@ -84,8 +84,8 @@ export const FIELDS = [
         kind: "cycle",
         values: REASONING_CYCLE,
         format: (p) => {
-            if (p.reasoningBudget === -1)
-                return `${style.red}unrestricted${style.reset}`;
+            if (p.reasoningBudget === UNRESTRICTED_REASONING_BUDGET)
+                return `${style.red}${formatReasoningBudget(p.reasoningBudget)}${style.reset}`;
             if (p.reasoningBudget === 0)
                 return `${style.cyan}thinking off${style.reset}`;
             return `${p.reasoningBudget} tokens`;
@@ -114,6 +114,12 @@ export const FIELDS = [
 ];
 export class App {
     constructor({ runtime, listenPort, listenHost }) {
+        /**
+         * The VRAM fit behind the resident model, so a benchmark can record whether
+         * the profile it measured was the profile the user configured. Keyed by model
+         * id because a fit computed for one model says nothing about the next.
+         */
+        this.lastFit = null;
         this.filterMode = false;
         this.confirming = null;
         this.picker = null;
@@ -199,6 +205,7 @@ export class App {
     async loadModelFitted(target) {
         const info = this.gpuInfo || (await gpu.query());
         let profile = profiles.forModel(this.store, target);
+        this.lastFit = null;
         if (info) {
             const fit = vram.fitToBudget({
                 model: target,
@@ -208,6 +215,9 @@ export class App {
             });
             if (!fit.adjusted && !fit.budget.fits)
                 throw new Error(fit.reason ?? undefined);
+            // Held for the benchmark to record: once `fit.profile` is applied, the
+            // context the user actually asked for is gone from every other source.
+            this.lastFit = { modelId: target.id, fit };
             profile = fit.profile;
         }
         this.setStatus(`switching to ${target.displayName}…`, "info");
@@ -615,7 +625,7 @@ export class App {
         }
         const plan = planDelete(model);
         this.confirming = { kind: "delete", model };
-        this.setStatus(`delete ${model.displayName} — frees ${vram.formatGiB(plan.bytes)}` +
+        this.setStatus(`delete ${model.displayName} - frees ${vram.formatGiB(plan.bytes)}` +
             `${plan.includesProjector ? " (incl. projector)" : ""}?   y / n`, "warn");
         this.draw();
     }
@@ -629,7 +639,7 @@ export class App {
                 const plan = deleteModelFiles(confirming.model);
                 this.reload();
                 void this.refreshDisk();
-                this.setStatus(`deleted ${confirming.model.displayName} — freed ${vram.formatGiB(plan.bytes)}`, "good");
+                this.setStatus(`deleted ${confirming.model.displayName} - freed ${vram.formatGiB(plan.bytes)}`, "good");
             });
         }
         else if (key === "n" || key === "escape") {
@@ -893,7 +903,7 @@ export class App {
         }
         const lines = [this.header(cols), ""];
         lines.push(...box({
-            title: `Download quant — ${truncate(picker.repo, Math.max(8, inner - 18))}`,
+            title: `Download quant - ${truncate(picker.repo, Math.max(8, inner - 18))}`,
             lines: rows,
             innerWidth: inner,
             footer: picker.loading
@@ -1101,7 +1111,7 @@ export class App {
                 const archiveId = archive.runId(model);
                 const healthSampler = health.start();
                 // stop() is idempotent (clearInterval); guarantee the 1s nvidia-smi
-                // sampler never outlives the run even if runSuite throws — otherwise a
+                // sampler never outlives the run even if runSuite throws - otherwise a
                 // failed bench leaks a recurring subprocess.
                 let sampled = false;
                 try {
@@ -1120,7 +1130,7 @@ export class App {
                                     `${p.title}: ${(p.score * 100).toFixed(0)}%  ${p.summary}`;
                             }
                             else if (p.phase === "failed")
-                                this.benchProgress.push(`${p.title}: failed — ${p.summary}`);
+                                this.benchProgress.push(`${p.title}: failed - ${p.summary}`);
                             this.draw();
                         },
                     });
@@ -1136,10 +1146,24 @@ export class App {
                         runtime: `${this.runtime.label} v${this.runtime.version}`,
                         system: report.system,
                         archiveId,
+                        args: this.supervisor.args,
+                        // Only when it belongs to the model actually being benchmarked - the
+                        // model may have been resident since before this fit was computed.
+                        fit: this.lastFit?.modelId === model.id ? this.lastFit.fit : null,
+                        calibration: profile ? profiles.getCalibration(this.store, model, profile) : null,
+                        suite: {
+                            // The TUI runs the full static suite; only concurrency varies, and
+                            // it tracks the profile's slot count the same way runSuite is called.
+                            execute: true,
+                            concurrency: Math.max(1, profile?.parallelSlots || 3),
+                            depths: null,
+                            only: null,
+                            mined: false,
+                        },
                     });
                     this.loadBenchResults();
                     this.loadRankings();
-                    this.benchProgress.push(`done — overall ${(report.overall * 100).toFixed(0)}% (${report.grade})`);
+                    this.benchProgress.push(`done - overall ${(report.overall * 100).toFixed(0)}% (${report.grade})`);
                     this.setStatus(`benchmark complete: ${model.displayName} ${(report.overall * 100).toFixed(0)}% (${report.grade})`, "good");
                 }
                 finally {
@@ -1347,7 +1371,7 @@ export class App {
             return box({
                 title: "Leaderboard",
                 lines: [
-                    `${style.grey}no benchmarks yet — select a model and press r to run one${style.reset}`,
+                    `${style.grey}no benchmarks yet - select a model and press r to run one${style.reset}`,
                 ],
                 innerWidth: innerWidth - 2,
             });
@@ -1383,7 +1407,7 @@ export class App {
         const bodyRows = Math.max(1, this.screen.rows - 1 - overhead);
         const body = [];
         if (logs.length === 0) {
-            body.push(`${style.grey}no logs yet — start a model with s to see llama-server output${style.reset}`);
+            body.push(`${style.grey}no logs yet - start a model with s to see llama-server output${style.reset}`);
         }
         else {
             for (const line of logs.slice(Math.max(0, logs.length - bodyRows)))
@@ -1658,19 +1682,19 @@ export class App {
         section("Change settings (Configuration panel)");
         item("← →", "change the selected field (toggle / cycle / ± step)");
         item("- +", "same as ← →");
-        item("Enter", "edit a number field — type digits, Enter saves, Esc cancels");
+        item("Enter", "edit a number field - type digits, Enter saves, Esc cancels");
         item("m", "set context to the largest size that fits in VRAM");
         section("Run the model");
         item("s", "start / load the selected model");
         item("x", "stop the running model");
-        item("c", "calibrate — measure real VRAM per token");
-        item("w", "sweep — find the best reasoning budget");
+        item("c", "calibrate - measure real VRAM per token");
+        item("w", "sweep - find the best reasoning budget");
         section("Manage models");
-        item("f", "find on Hugging Face — search and add a new model");
-        item("g", "get a quant — pick Q4/Q5/Q6… to download for this repo");
+        item("f", "find on Hugging Face - search and add a new model");
+        item("g", "get a quant - pick Q4/Q5/Q6… to download for this repo");
         item("D", "delete the selected model (frees disk, asks to confirm)");
         section("Views");
-        item("b", "benchmark mode — rank models, run the coding suite");
+        item("b", "benchmark mode - rank models, run the coding suite");
         item("l", "view the live llama-server log");
         item("/", "filter the model list (Enter apply, Esc clear)");
         item("r", "rescan the models folder");
@@ -1680,7 +1704,7 @@ export class App {
         item("q  Ctrl-C", "quit Otto Brain");
         const lines = [this.header(cols), ""];
         lines.push(...box({
-            title: "Help — every key and what it does",
+            title: "Help - every key and what it does",
             lines: rows,
             innerWidth: inner,
             footer: `${style.grey}esc or ? to go back${style.reset}`,
@@ -1690,8 +1714,8 @@ export class App {
     }
     /**
      * The key hints for the current mode, as an array of lines. Groups are
-     * deliberately broken onto separate lines — navigation first, then the
-     * actions — and each group wraps further only if the terminal is too narrow.
+     * deliberately broken onto separate lines - navigation first, then the
+     * actions - and each group wraps further only if the terminal is too narrow.
      */
     keybindings(cols) {
         let groups;
@@ -1752,14 +1776,14 @@ export class App {
         }
         else {
             groups = [
-                // Navigation — line one.
+                // Navigation - line one.
                 [
                     ["↑↓", "select"],
                     ["tab", "panel"],
                     ["←→", "change"],
                     ["enter", "edit"],
                 ],
-                // Actions — line two onward.
+                // Actions - line two onward.
                 [
                     ["s", "start"],
                     ["x", "stop"],

package/dist/vram.d.ts

@@ -53,12 +53,19 @@ export interface FitResult {
     adjusted: boolean;
     reason: string | null;
     budget: Budget;
+    /**
+     * The context the caller asked for, before any adjustment. `profile` is the
+     * one that will actually run, so once a fit has been applied the original is
+     * unrecoverable from it - and a benchmark that does not record what it asked
+     * for cannot later explain why it scored the way it did.
+     */
+    requestedContextSize: number;
 }
 /**
  * Adapt a profile to the hardware it is about to run on.
  *
  * Refusing to load because a saved profile asks for more context than this
- * machine has is unhelpful when a slightly smaller context would work — and it
+ * machine has is unhelpful when a slightly smaller context would work - and it
  * is the difference between a model being usable on a 32GB desktop and a 24GB
  * laptop. Clamp the context instead, and report what changed.
  */

package/dist/vram.js

@@ -99,14 +99,15 @@ export function maxContextThatFits({ model, profile, calibration, totalVramBytes
  * Adapt a profile to the hardware it is about to run on.
  *
  * Refusing to load because a saved profile asks for more context than this
- * machine has is unhelpful when a slightly smaller context would work — and it
+ * machine has is unhelpful when a slightly smaller context would work - and it
  * is the difference between a model being usable on a 32GB desktop and a 24GB
  * laptop. Clamp the context instead, and report what changed.
  */
 export function fitToBudget({ model, profile, calibration, totalVramBytes, reserveBytes = 1.5 * GIB, }) {
+    const requestedContextSize = profile.contextSize;
     const initial = budget({ model, profile, calibration, totalVramBytes, reserveBytes });
     if (initial.fits) {
-        return { profile, adjusted: false, reason: null, budget: initial };
+        return { profile, adjusted: false, reason: null, budget: initial, requestedContextSize };
     }
     const max = maxContextThatFits({ model, profile, calibration, totalVramBytes, reserveBytes });
     if (!max || max < 4096) {
@@ -116,14 +117,16 @@ export function fitToBudget({ model, profile, calibration, totalVramBytes, reser
             reason: `does not fit at any usable context (needs ${formatGiB(initial.totalBytes)}, ` +
                 `${formatGiB(initial.usableBytes)} usable)`,
             budget: initial,
+            requestedContextSize,
         };
     }
     const fitted = { ...profile, contextSize: max };
     return {
         profile: fitted,
         adjusted: true,
-        reason: `context reduced ${profile.contextSize.toLocaleString()} -> ${max.toLocaleString()} to fit ${formatGiB(totalVramBytes)} of VRAM`,
+        reason: `context reduced ${requestedContextSize.toLocaleString()} -> ${max.toLocaleString()} to fit ${formatGiB(totalVramBytes)} of VRAM`,
         budget: budget({ model, profile: fitted, calibration, totalVramBytes, reserveBytes }),
+        requestedContextSize,
     };
 }
 export function formatGiB(bytes, digits = 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/brain",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "description": "Otto Brain - self-contained host for local GGUF models, with measured VRAM budgeting and reasoning-budget control",
   "license": "AGPL-3.0-or-later",
   "bin": {