@otto-code/brain 0.8.1 → 0.8.2

package/dist/config/paths.d.ts

@@ -4,11 +4,13 @@ export interface BrainPaths {
     configFile: string;
     profilesFile: string;
     catalogFile: string;
+    renameMapFile: string;
     modelsDir: string;
     runtimesDir: string;
     pidFile: string;
     activityFile: string;
     logFile: string;
+    logsDir: string;
     resultsDir: string;
 }
 export declare function resolveBrainPaths(env?: NodeJS.ProcessEnv): BrainPaths;

package/dist/config/paths.js

@@ -15,6 +15,7 @@ export function resolveBrainPaths(env = process.env) {
         configFile: path.join(root, "config.json"),
         profilesFile: path.join(root, "profiles.json"),
         catalogFile: path.join(root, "catalog.json"),
+        renameMapFile: path.join(root, "rename-map.json"),
         modelsDir: path.join(root, "models"),
         runtimesDir: path.join(root, "runtimes"),
         pidFile: path.join(root, "otto-brain.pid"),
@@ -23,6 +24,7 @@ export function resolveBrainPaths(env = process.env) {
         // service - which is what answers /__host/status - never sees them otherwise.
         activityFile: path.join(root, "otto-brain.activity"),
         logFile: path.join(root, "otto-brain.log"),
+        logsDir: path.join(root, "logs"),
         resultsDir: path.join(root, "results"),
     };
 }

package/dist/models/index.js

@@ -4,6 +4,7 @@ import { CatalogSchema } from "../config/schema.js";
 import { loadCatalog } from "../config/store.js";
 import { resolveModelsDirs } from "./dirs.js";
 import { enrichWithCatalog } from "./enrich.js";
+import { loadRenameMap } from "./rename-map.js";
 import { scan } from "./scan.js";
 export * from "./scan.js";
 export { pickModel, pickAutoModel } from "./pick.js";
@@ -30,6 +31,12 @@ export function scanModels(config, env = process.env, options = {}) {
         }
     }
     const enriched = enrichWithCatalog(all, loadCatalogSafe(env));
+    const renameMap = loadRenameMap(resolveBrainPaths(env));
+    for (const model of enriched) {
+        if (renameMap[model.id]) {
+            model.displayName = renameMap[model.id];
+        }
+    }
     enriched.sort((a, b) => a.displayName.localeCompare(b.displayName));
     return enriched;
 }

package/dist/models/rename-map.d.ts

@@ -0,0 +1,12 @@
+import { type BrainPaths } from "../config/paths.js";
+/** Every function here only ever touches renameMapFile; narrowed to that one
+ * field (rather than the full BrainPaths) so a test's fake paths object is
+ * actually type-checked instead of passing only because tsconfig excludes
+ * *.test.ts from the build. */
+type RenameMapPaths = Pick<BrainPaths, "renameMapFile">;
+export declare function loadRenameMap(paths?: RenameMapPaths): Record<string, string>;
+export declare function saveRenameMap(map: Record<string, string>, paths?: RenameMapPaths): void;
+export declare function updateDisplayName(modelId: string, displayName: string, paths?: RenameMapPaths): Record<string, string>;
+export declare function deleteDisplayName(modelId: string, paths?: RenameMapPaths): Record<string, string>;
+export {};
+//# sourceMappingURL=rename-map.d.ts.map

package/dist/models/rename-map.js

@@ -0,0 +1,39 @@
+/**
+ * User-defined model display-name overrides, keyed by model id, persisted at
+ * `$OTTO_HOME/otto-brain/rename-map.json`. Kept as its own file (rather than a
+ * field on the profiles store) so renaming a model never touches the
+ * calibration/profile data profiles.json carries.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { resolveBrainPaths } from "../config/paths.js";
+import { writePrivateFileAtomicSync } from "../config/private-files.js";
+const RenameMapSchema = z.record(z.string());
+export function loadRenameMap(paths = resolveBrainPaths()) {
+    if (!existsSync(paths.renameMapFile))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(paths.renameMapFile, "utf8"));
+        const result = RenameMapSchema.safeParse(parsed);
+        return result.success ? result.data : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function saveRenameMap(map, paths = resolveBrainPaths()) {
+    writePrivateFileAtomicSync(paths.renameMapFile, `${JSON.stringify(map, null, 2)}\n`);
+}
+export function updateDisplayName(modelId, displayName, paths = resolveBrainPaths()) {
+    const map = loadRenameMap(paths);
+    map[modelId] = displayName;
+    saveRenameMap(map, paths);
+    return map;
+}
+export function deleteDisplayName(modelId, paths = resolveBrainPaths()) {
+    const map = loadRenameMap(paths);
+    delete map[modelId];
+    saveRenameMap(map, paths);
+    return map;
+}
+//# sourceMappingURL=rename-map.js.map

package/dist/service/host-api.d.ts

@@ -48,6 +48,10 @@ export interface HostCapabilities {
     resources: boolean;
     /** GET /__host/models */
     inventory: boolean;
+    /** POST /__host/model/rename */
+    rename: boolean;
+    /** POST /__host/model/rename/reset */
+    reset: boolean;
     /** Whether writes are currently permitted (allowRemoteConfig). */
     writable: boolean;
 }

package/dist/service/host-api.js

@@ -1,9 +1,11 @@
 import { calibrationInfo, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, } from "../config/profile-edit.js";
 import { forModel, getCalibration, put } from "../config/profiles.js";
 import { deleteModelFiles, diskUsage, planDelete, totalModelBytes } from "../models/manage.js";
+import { deleteDisplayName, updateDisplayName } from "../models/rename-map.js";
 import * as vram from "../vram.js";
 import { errorMessage, readJsonBody, sendError, sendJson } from "./http-util.js";
 const MAX_PATCH_BYTES = 256 * 1024;
+const MAX_DISPLAY_NAME = 200;
 const DEFAULT_LOG_LINES = 200;
 function stateOf(supervisor, model) {
     if (!supervisor.model || supervisor.model.id !== model.id)
@@ -101,6 +103,8 @@ export function createHostApi(deps) {
         load: true,
         resources: true,
         inventory: true,
+        rename: true,
+        reset: true,
         writable: deps.getAllowWrite(),
     });
     /** Refuse a write unless the owner opted into remote configuration. */
@@ -180,6 +184,53 @@ export function createHostApi(deps) {
             })();
         });
     };
+    const handleRename = (req, res, model) => {
+        readJsonBody(req, MAX_DISPLAY_NAME + 64, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            const body = result.body;
+            const displayName = body.displayName;
+            if (typeof displayName !== "string" || displayName.trim().length === 0) {
+                sendError(res, 400, "displayName must be a non-empty string");
+                return;
+            }
+            if (displayName.length > MAX_DISPLAY_NAME) {
+                sendError(res, 400, `displayName must be at most ${MAX_DISPLAY_NAME} characters`);
+                return;
+            }
+            if (/[^\x20-\x7E]/.test(displayName)) {
+                sendError(res, 400, "displayName must not contain control characters or non-ASCII");
+                return;
+            }
+            // /v1/models keys its `id` on displayName (router.ts) and both the
+            // completion path and defaultModel/switchTo resolve a model by
+            // `displayName === name || id === name` - a collision here would make
+            // one of the two models unreachable by name with no error anywhere.
+            const conflict = deps
+                .getCatalog()
+                .find((m) => m.id !== model.id && (m.displayName === displayName || m.id === displayName));
+            if (conflict) {
+                sendError(res, 409, `another model is already named "${displayName}"`);
+                return;
+            }
+            updateDisplayName(model.id, displayName);
+            sendJson(res, { displayName });
+        });
+    };
+    const handleReset = (req, res, model) => {
+        readJsonBody(req, 4096, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            deleteDisplayName(model.id);
+            const catalog = deps.rescan();
+            const updated = resolveModel(catalog, model.id);
+            sendJson(res, { displayName: updated ? updated.displayName : model.displayName });
+        });
+    };
     const handleBudget = (res, model, params) => {
         void (async () => {
             try {
@@ -326,6 +377,8 @@ export function createHostApi(deps) {
             "/__host/model/budget",
             "/__host/model/load",
             "/__host/model/fields",
+            "/__host/model/rename",
+            "/__host/model/rename/reset",
         ]);
         if (!modelRoutes.has(route))
             return false;
@@ -359,6 +412,18 @@ export function createHostApi(deps) {
             handleLoad(res, model);
             return true;
         }
+        if (route === "/__host/model/rename" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleRename(req, res, model);
+            return true;
+        }
+        if (route === "/__host/model/rename/reset" && method === "POST") {
+            if (!guardWrite(res))
+                return true;
+            handleReset(req, res, model);
+            return true;
+        }
         if (route === "/__host/model" && method === "DELETE") {
             if (!guardWrite(res))
                 return true;

package/dist/service/router.js

@@ -298,6 +298,25 @@ function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, r
             }
             res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
             const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
+            const upstreamResponseFailed = (error) => {
+                if (settled)
+                    return;
+                const message = `llama-server response ended unexpectedly: ${error.message}`;
+                telemetry.record({
+                    at: new Date().toISOString(),
+                    path: req.url,
+                    verdict: "failed",
+                    error: message,
+                });
+                logger?.warn?.(message);
+                // Headers may already be on the wire for an SSE response. Destroying
+                // it is the only honest result, but `done()` still releases the queue.
+                if (!res.writableEnded && !res.destroyed)
+                    res.destroy(error);
+                done();
+            };
+            upstreamRes.once("aborted", () => upstreamResponseFailed(new Error("upstream response aborted")));
+            upstreamRes.once("error", upstreamResponseFailed);
             if (isStream) {
                 let sawContent = false;
                 let sawReasoning = false;

package/dist/service/run-log.d.ts

@@ -0,0 +1,8 @@
+export interface BrainRunLog {
+    path: string;
+    write(line: string): void;
+}
+/** Start a fresh Brain log and prune only expired Brain run logs. */
+export declare function createBrainRunLog(env?: NodeJS.ProcessEnv): BrainRunLog;
+export declare function pruneBrainRunLogs(logsDir: string, now?: number): void;
+//# sourceMappingURL=run-log.d.ts.map

package/dist/service/run-log.js

@@ -0,0 +1,39 @@
+/** Durable, per-service-run diagnostics for Otto Brain. */
+import { appendFileSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import path from "node:path";
+import { resolveBrainPaths } from "../config/paths.js";
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const RUN_LOG_SUFFIX = "-brain.log";
+/** Start a fresh Brain log and prune only expired Brain run logs. */
+export function createBrainRunLog(env = process.env) {
+    const { logsDir } = resolveBrainPaths(env);
+    const startedAt = new Date();
+    const stamp = startedAt
+        .toISOString()
+        .replace(/[-:]/g, "")
+        .replace(/\.\d{3}Z$/, "Z");
+    const filePath = path.join(logsDir, `${stamp}-${process.pid}${RUN_LOG_SUFFIX}`);
+    try {
+        mkdirSync(logsDir, { recursive: true });
+        pruneBrainRunLogs(logsDir, startedAt.getTime());
+    }
+    catch { }
+    const write = (line) => {
+        try {
+            appendFileSync(filePath, `${new Date().toISOString()} ${line}\n`, "utf8");
+        }
+        catch { }
+    };
+    write(`Brain service started (pid ${process.pid})`);
+    return { path: filePath, write };
+}
+export function pruneBrainRunLogs(logsDir, now = Date.now()) {
+    for (const entry of readdirSync(logsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(RUN_LOG_SUFFIX))
+            continue;
+        const filePath = path.join(logsDir, entry.name);
+        if (now - statSync(filePath).mtimeMs > RETENTION_MS)
+            rmSync(filePath, { force: true });
+    }
+}
+//# sourceMappingURL=run-log.js.map

package/dist/service/serve.js

@@ -27,6 +27,7 @@ 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,6 +94,11 @@ 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);
+    };
     const runtime = resolveRuntime(config, env);
     if (!runtime) {
         throw new CommandError({
@@ -156,15 +162,17 @@ export async function startService({ config, modelNeedle, env = process.env, onL
             });
         }
         if (fit.adjusted && fit.reason)
-            onLog(`note: ${fit.reason}`);
+            log(`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)
@@ -262,7 +270,7 @@ export async function startService({ config, modelNeedle, env = process.env, onL
     const handler = withAuth(createRouter({
         supervisor,
         telemetry,
-        logger: { warn: (m) => onLog(`WARN ${m}`) },
+        logger: { warn: (m) => log(`WARN ${m}`) },
         getCatalog: () => catalog,
         loadModel,
         version: resolveVersion(),
@@ -311,8 +319,10 @@ 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}`);
     const stop = async () => {
         certManager?.stop();
+        log("Brain service stopping");
         await supervisor.stop();
         await new Promise((resolve) => server.close(() => resolve()));
         removePidFile(env);

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;
+        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;

package/dist/sysmon.js

@@ -1,3 +1,9 @@
+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 _SlotActivityTracker_previous;
 import os from "node:os";
 import http from "node:http";
 import { query } from "./gpu.js";
@@ -98,12 +104,57 @@ export function summariseSlots(rows) {
         }),
     };
 }
+/** Measures throughput from successive `/slots` snapshots, without guessing. */
+export class SlotActivityTracker {
+    constructor() {
+        _SlotActivityTracker_previous.set(this, new Map());
+    }
+    sample(rows, now = Date.now()) {
+        const threads = rows.flatMap((row, slot) => {
+            const record = row;
+            if (!isProcessing(record)) {
+                __classPrivateFieldGet(this, _SlotActivityTracker_previous, "f").delete(slot);
+                return [];
+            }
+            const promptTokens = counter(record, ["n_past", "n_prompt_tokens_processed"]);
+            const generatedTokens = decodedTokens(record);
+            const phase = generatedTokens === 0 ? "prefill" : "decode";
+            const previous = __classPrivateFieldGet(this, _SlotActivityTracker_previous, "f").get(slot);
+            const elapsedSeconds = previous ? (now - previous.at) / 1000 : 0;
+            const rate = (current, before) => elapsedSeconds > 0 && before !== undefined && current >= before
+                ? (current - before) / elapsedSeconds
+                : null;
+            __classPrivateFieldGet(this, _SlotActivityTracker_previous, "f").set(slot, { at: now, promptTokens, generatedTokens });
+            return [
+                {
+                    slot,
+                    phase,
+                    promptTokens,
+                    generatedTokens,
+                    promptTokensPerSecond: phase === "prefill" ? rate(promptTokens, previous?.promptTokens) : null,
+                    tokensPerSecond: phase === "decode" ? rate(generatedTokens, previous?.generatedTokens) : null,
+                },
+            ];
+        });
+        return { ...summariseSlots(rows), threads };
+    }
+}
+_SlotActivityTracker_previous = new WeakMap();
+function counter(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+    }
+    return 0;
+}
+const slotActivityTracker = new SlotActivityTracker();
 /** 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);
+    return slotActivityTracker.sample(data);
 }
 export { slots };
 /** One combined reading for the status panel. */

package/dist/tui/app.d.ts

@@ -19,7 +19,7 @@ interface FieldContext {
 }
 /** A pending destructive action awaiting y/n. */
 interface ConfirmState {
-    kind: "delete";
+    kind: "delete" | "reset-name";
     model: Model;
 }
 /** One downloadable quant in the picker, with whether it is already on disk. */
@@ -114,6 +114,11 @@ export declare class App {
         fit: vram.FitResult;
     } | null;
     filterMode: boolean;
+    renaming: boolean;
+    renameBuffer: string;
+    /** ids with a persisted rename-map override, so "reset name" can tell the
+     * user there is nothing to reset instead of round-tripping for a no-op. */
+    renamedIds: Set<string>;
     confirming: ConfirmState | null;
     picker: PickerState | null;
     search: SearchState | null;
@@ -127,6 +132,13 @@ export declare class App {
     /** Fit a model to the live VRAM budget and (re)start the server on it. */
     loadModelFitted(target: Model): Promise<void>;
     startRouter(): Promise<void>;
+    /** POST /__host/model/rename?id=… - the one host-api route this embedded
+     * router serves, so the TUI's rename form and a remote-brain client hit the
+     * same wire shape. */
+    handleRenameRequest(req: http.IncomingMessage, res: http.ServerResponse): void;
+    /** POST /__host/model/rename/reset?id=… - clears this model's rename-map
+     * override and returns the scan-derived default name it reverted to. */
+    handleResetRequest(req: http.IncomingMessage, res: http.ServerResponse): void;
     reload(): void;
     /** Mean-of-runs rank + score per model, for ordering and badging the list. */
     loadRankings(): void;
@@ -143,6 +155,16 @@ export declare class App {
     onKey(key: string): void;
     onFilterKey(key: string): void;
     onEditKey(key: string): void;
+    beginRename(): void;
+    onRenameKey(key: string): void;
+    /** POST the new display name to this TUI's own local router (see
+     * handleRenameRequest / startRouter), then rescan so the renamed catalog
+     * entry - and its persisted override - are reflected immediately. */
+    submitRename(): Promise<void>;
+    beginResetName(): void;
+    /** POST to this TUI's own local router (see handleResetRequest), then
+     * rescan so the reverted name is reflected immediately. */
+    submitResetName(model: Model): Promise<void>;
     move(delta: number): void;
     usableFields(): number[];
     /** Read a profile field by key, without narrowing to a single value type. */
@@ -189,6 +211,9 @@ export declare class App {
      */
     renderFitted(lines: string[]): void;
     draw(): void;
+    /** The rename input line shown above the footer while renaming is active:
+     * the current name in grey, the buffer typed so far, and a cursor. */
+    renameLine(cols: number): string;
     /**
      * Benchmark workspace: the model list on the left, the selected model's
      * scorecard where Configuration sits in serve mode, and the ranked leaderboard

package/dist/tui/app.js

@@ -8,6 +8,8 @@ import { calibrate } from "../ops/calibrate.js";
 import { sweep } from "../ops/sweep.js";
 import * as results from "../ops/results.js";
 import * as archive from "../ops/archive.js";
+import { deleteDisplayName, loadRenameMap, updateDisplayName } from "../models/rename-map.js";
+import { readJsonBody, sendError, sendJson } from "../service/http-util.js";
 import { Supervisor } from "../service/supervisor.js";
 import { createRouter, Telemetry } from "../service/router.js";
 import * as sysmon from "../sysmon.js";
@@ -28,6 +30,9 @@ const REASONING_CYCLE = [0, 512, 1024, 1536, 3072, -1];
 // hardware; draft models likewise do not help, so nothing boosts for them.
 const VISION_RANK_BONUS = 0.03;
 const THINKING_RANK_BONUS = 0.02;
+// Mirrors host-api.ts's MAX_DISPLAY_NAME - the rename form posts to the same
+// wire shape (see startRouter), so both paths must enforce the same limit.
+const MAX_DISPLAY_NAME = 200;
 /** Editable configuration fields, in display order. */
 export const FIELDS = [
     {
@@ -121,6 +126,11 @@ export class App {
          */
         this.lastFit = null;
         this.filterMode = false;
+        this.renaming = false;
+        this.renameBuffer = "";
+        /** ids with a persisted rename-map override, so "reset name" can tell the
+         * user there is nothing to reset instead of round-tripping for a no-op. */
+        this.renamedIds = new Set();
         this.confirming = null;
         this.picker = null;
         this.search = null;
@@ -231,7 +241,22 @@ export class App {
             getCatalog: () => this.catalog,
             loadModel: (m) => this.loadModelFitted(m),
         });
-        const server = http.createServer(handler);
+        // The rename form posts to this local router (see submitRename) rather than
+        // calling updateDisplayName in-process, so a future remote-brain TUI hits the
+        // same code path this does. The full host-api surface is not wired in here -
+        // only these two routes - since nothing else in the TUI needs it over HTTP.
+        const server = http.createServer((req, res) => {
+            const path = (req.url ?? "").split("?")[0];
+            if (req.method === "POST" && path === "/__host/model/rename") {
+                this.handleRenameRequest(req, res);
+                return;
+            }
+            if (req.method === "POST" && path === "/__host/model/rename/reset") {
+                this.handleResetRequest(req, res);
+                return;
+            }
+            handler(req, res);
+        });
         this.routerServer = server;
         server.keepAliveTimeout = 75000;
         server.requestTimeout = 0;
@@ -244,10 +269,73 @@ export class App {
             this.routerServer = null;
         });
     }
+    /** POST /__host/model/rename?id=… - the one host-api route this embedded
+     * router serves, so the TUI's rename form and a remote-brain client hit the
+     * same wire shape. */
+    handleRenameRequest(req, res) {
+        const url = new URL(req.url ?? "", "http://brain.local");
+        const id = url.searchParams.get("id");
+        const model = id ? this.catalog.find((m) => m.id === id) : null;
+        if (!model) {
+            sendError(res, 404, id ? `model "${id}" was not found` : "an ?id= is required");
+            return;
+        }
+        readJsonBody(req, 4096, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            const body = result.body;
+            const displayName = body.displayName;
+            if (typeof displayName !== "string" || displayName.trim().length === 0) {
+                sendError(res, 400, "displayName must be a non-empty string");
+                return;
+            }
+            if (displayName.length > MAX_DISPLAY_NAME) {
+                sendError(res, 400, `displayName must be at most ${MAX_DISPLAY_NAME} characters`);
+                return;
+            }
+            if (/[^\x20-\x7E]/.test(displayName)) {
+                sendError(res, 400, "displayName must not contain control characters or non-ASCII");
+                return;
+            }
+            // Same collision guard as host-api.ts's handleRename - both /v1/models
+            // and defaultModel/switchTo resolve a model by displayName, so a
+            // duplicate silently strands one of the two models unreachable by name.
+            const conflict = this.catalog.find((m) => m.id !== model.id && (m.displayName === displayName || m.id === displayName));
+            if (conflict) {
+                sendError(res, 409, `another model is already named "${displayName}"`);
+                return;
+            }
+            updateDisplayName(model.id, displayName);
+            sendJson(res, { displayName });
+        });
+    }
+    /** POST /__host/model/rename/reset?id=… - clears this model's rename-map
+     * override and returns the scan-derived default name it reverted to. */
+    handleResetRequest(req, res) {
+        const url = new URL(req.url ?? "", "http://brain.local");
+        const id = url.searchParams.get("id");
+        const model = id ? this.catalog.find((m) => m.id === id) : null;
+        if (!model) {
+            sendError(res, 404, id ? `model "${id}" was not found` : "an ?id= is required");
+            return;
+        }
+        readJsonBody(req, 4096, (result) => {
+            if (!result.ok) {
+                sendError(res, 400, result.error);
+                return;
+            }
+            deleteDisplayName(model.id);
+            const rescanned = scanModels(loadBrainConfig()).find((m) => m.id === model.id);
+            sendJson(res, { displayName: rescanned ? rescanned.displayName : model.displayName });
+        });
+    }
     // -------------------------------------------------------------------- state
     reload() {
         const config = loadBrainConfig();
         this.catalog = scanModels(config);
+        this.renamedIds = new Set(Object.keys(loadRenameMap()));
         this.loadRankings();
         this.selected = Math.min(this.selected, Math.max(0, this.visible.length - 1));
         this.syncProfile();
@@ -346,6 +434,8 @@ export class App {
     }
     // -------------------------------------------------------------------- input
     onKey(key) {
+        if (this.renaming)
+            return this.onRenameKey(key);
         if (this.editing)
             return this.onEditKey(key);
         if (this.filterMode)
@@ -434,6 +524,14 @@ export class App {
             case "D":
                 this.beginDelete();
                 break;
+            case "R":
+                if (this.focus === "models")
+                    this.beginRename();
+                break;
+            case "u":
+                if (this.focus === "models")
+                    this.beginResetName();
+                break;
             case "r":
                 this.reload();
                 break;
@@ -500,6 +598,117 @@ export class App {
         }
         this.draw();
     }
+    beginRename() {
+        const model = this.model;
+        if (!model)
+            return;
+        this.renaming = true;
+        this.renameBuffer = "";
+        this.setStatus(`rename "${model.displayName}" → `, "info");
+    }
+    onRenameKey(key) {
+        if (key === "escape") {
+            this.renaming = false;
+            this.renameBuffer = "";
+            this.setStatus("rename cancelled", "info");
+            return;
+        }
+        if (key === "enter") {
+            void this.submitRename();
+            return;
+        }
+        if (key === "backspace") {
+            this.renameBuffer = this.renameBuffer.slice(0, -1);
+        }
+        else if (key === "space") {
+            if (this.renameBuffer.length < 80)
+                this.renameBuffer += " ";
+        }
+        else if (key.length === 1 && key >= " " && this.renameBuffer.length < 80) {
+            this.renameBuffer += key;
+        }
+        this.draw();
+    }
+    /** POST the new display name to this TUI's own local router (see
+     * handleRenameRequest / startRouter), then rescan so the renamed catalog
+     * entry - and its persisted override - are reflected immediately. */
+    async submitRename() {
+        const model = this.model;
+        if (!model) {
+            this.renaming = false;
+            this.draw();
+            return;
+        }
+        const newName = this.renameBuffer.trim();
+        if (!newName) {
+            this.renaming = false;
+            this.renameBuffer = "";
+            this.setStatus("rename cancelled - name cannot be empty", "warn");
+            return;
+        }
+        await this.guard("rename", async () => {
+            const url = `http://127.0.0.1:${this.listenPort}/__host/model/rename?id=${encodeURIComponent(model.id)}`;
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ displayName: newName }),
+            });
+            if (!res.ok) {
+                let message = `HTTP ${res.status}`;
+                try {
+                    const body = (await res.json());
+                    if (body.error?.message)
+                        message = body.error.message;
+                }
+                catch {
+                    /* non-JSON error body */
+                }
+                throw new Error(message);
+            }
+            this.renaming = false;
+            this.renameBuffer = "";
+            this.reload();
+            this.setStatus(`renamed to ${newName}`, "good");
+        });
+    }
+    beginResetName() {
+        const model = this.model;
+        if (!model)
+            return;
+        if (!this.renamedIds.has(model.id)) {
+            this.setStatus(`"${model.displayName}" has no custom name to reset`, "info");
+            return;
+        }
+        this.confirming = { kind: "reset-name", model };
+        this.setStatus(`reset "${model.displayName}" to its default name?   y / n`, "warn");
+        this.draw();
+    }
+    /** POST to this TUI's own local router (see handleResetRequest), then
+     * rescan so the reverted name is reflected immediately. */
+    async submitResetName(model) {
+        await this.guard("reset name", async () => {
+            const url = `http://127.0.0.1:${this.listenPort}/__host/model/rename/reset?id=${encodeURIComponent(model.id)}`;
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+            });
+            if (!res.ok) {
+                let message = `HTTP ${res.status}`;
+                try {
+                    const body = (await res.json());
+                    if (body.error?.message)
+                        message = body.error.message;
+                }
+                catch {
+                    /* non-JSON error body */
+                }
+                throw new Error(message);
+            }
+            const body = (await res.json());
+            this.reload();
+            this.setStatus(`reset to ${body.displayName ?? "its default name"}`, "good");
+        });
+    }
     move(delta) {
         if (this.focus === "models") {
             const list = this.visible;
@@ -635,16 +844,21 @@ export class App {
             return;
         if (key === "y") {
             this.confirming = null;
-            void this.guard("delete", async () => {
-                const plan = deleteModelFiles(confirming.model);
-                this.reload();
-                void this.refreshDisk();
-                this.setStatus(`deleted ${confirming.model.displayName} - freed ${vram.formatGiB(plan.bytes)}`, "good");
-            });
+            if (confirming.kind === "delete") {
+                void this.guard("delete", async () => {
+                    const plan = deleteModelFiles(confirming.model);
+                    this.reload();
+                    void this.refreshDisk();
+                    this.setStatus(`deleted ${confirming.model.displayName} - freed ${vram.formatGiB(plan.bytes)}`, "good");
+                });
+            }
+            else {
+                void this.submitResetName(confirming.model);
+            }
         }
         else if (key === "n" || key === "escape") {
             this.confirming = null;
-            this.setStatus("delete cancelled", "info");
+            this.setStatus(confirming.kind === "delete" ? "delete cancelled" : "reset cancelled", "info");
             this.draw();
         }
     }
@@ -1250,10 +1464,22 @@ export class App {
         lines.push(...budget);
         lines.push("");
         lines.push(...status);
+        if (this.renaming) {
+            lines.push("");
+            lines.push(this.renameLine(cols - 1));
+        }
         lines.push("");
         lines.push(...footer);
         this.renderFitted(lines);
     }
+    /** The rename input line shown above the footer while renaming is active:
+     * the current name in grey, the buffer typed so far, and a cursor. */
+    renameLine(cols) {
+        const model = this.model;
+        const name = model ? model.displayName : "";
+        return truncate(`${style.brightYellow}rename${style.reset}  ${style.grey}${name}${style.reset} → ` +
+            `${this.renameBuffer}${style.brightCyan}▏${style.reset}`, cols);
+    }
     /**
      * Benchmark workspace: the model list on the left, the selected model's
      * scorecard where Configuration sits in serve mode, and the ranked leaderboard
@@ -1693,6 +1919,8 @@ export class App {
         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)");
+        item("R", "rename the selected model (Enter saves, Esc cancels)");
+        item("u", "reset the selected model's name to its default (asks to confirm)");
         section("Views");
         item("b", "benchmark mode - rank models, run the coding suite");
         item("l", "view the live llama-server log");
@@ -1719,10 +1947,20 @@ export class App {
      */
     keybindings(cols) {
         let groups;
-        if (this.confirming) {
+        if (this.renaming) {
+            groups = [
+                [
+                    ["type", "rename"],
+                    ["enter", "save"],
+                    ["esc", "cancel"],
+                ],
+            ];
+        }
+        else if (this.confirming) {
+            const label = this.confirming.kind === "delete" ? "confirm delete" : "confirm reset";
             groups = [
                 [
-                    ["y", "confirm delete"],
+                    ["y", label],
                     ["n", "cancel"],
                 ],
             ];
@@ -1793,6 +2031,8 @@ export class App {
                     ["f", "find on HF"],
                     ["g", "get quant"],
                     ["D", "delete"],
+                    ["R", "rename"],
+                    ["u", "reset name"],
                     ["b", "benchmarks"],
                     ["l", "logs"],
                     ["/", "filter"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/brain",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "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": {