@otto-code/brain 0.7.6 → 0.8.0

package/dist/bench/context-corpus.js

@@ -133,7 +133,7 @@ function padTo(body, budgetChars, seed) {
 }
 /** Build one spec part covering `stages`, padded to `budgetChars`. */
 function specPart(partIndex, stages, budgetChars) {
-    const heading = `# Pipeline specification — part ${String(partIndex).padStart(2, "0")}\n\n` +
+    const heading = `# Pipeline specification - part ${String(partIndex).padStart(2, "0")}\n\n` +
         `This part defines the rule for stages ${stages[0].index}–${stages[stages.length - 1].index}. ` +
         `Each stage's module in the working copy is a passthrough placeholder; implement its \`apply(x)\` ` +
         `exactly as written here. All arithmetic is bounded modulo 1000 and returns an integer.\n`;
@@ -176,8 +176,8 @@ export function generateContextCorpus({ targetTokens }) {
             "`python -m unittest test_pipeline`.\n";
     files["docs/OVERVIEW.md"] =
         "# Specification overview\n\nThe pipeline applies each stage's `apply(x)` in order, starting " +
-            `from ${PIPELINE_START}. There are ${stageCount} stages. The rule for each stage — its ` +
-            "operation and operand — is defined in the numbered parts under `docs/spec/`. The code carries " +
+            `from ${PIPELINE_START}. There are ${stageCount} stages. The rule for each stage - its ` +
+            "operation and operand - is defined in the numbered parts under `docs/spec/`. The code carries " +
             "no hint of the operands; you must read the spec.\n";
     for (let p = 0; p < partCount; p += 1) {
         const slice = stages.slice(p * partStride, (p + 1) * partStride);

package/dist/bench/corpus.js

@@ -193,7 +193,7 @@ Rules are applied in **descending priority** (highest \`priority\` first). Two
 rules with equal priority may be applied in any order; the specification is
 written so that the result does not depend on the order of equal-priority rules.
 
-### Base amount — the load-bearing rule
+### Base amount - the load-bearing rule
 
 Every rule's discount is computed against the **original subtotal**, NOT against
 the running total after earlier rules. Discounts do **not** compound. A 30% rule
@@ -203,7 +203,7 @@ and a 40% rule on a $100.00 order remove \`$30.00 + $40.00 = $70.00\`, they do
 This is the single most common mistake when re-implementing the engine: applying
 each discount to the amount left by the previous one. Do not do that.
 
-### Combined cap — the other load-bearing rule
+### Combined cap - the other load-bearing rule
 
 The **sum** of all rule discounts is capped at **50% of the original subtotal**.
 Once the accumulated discount reaches half the subtotal, no further discount is

package/dist/bench/curated-repos.js

@@ -19,7 +19,7 @@ export const CURATED_REPOS = [
         workspaceDir: "packages/protocol",
         ref: "origin/main",
         maxTasks: 3,
-        note: "schema/validation workspace — fast suite, no heavy deps",
+        note: "schema/validation workspace - fast suite, no heavy deps",
     },
     {
         name: "brain",
@@ -27,7 +27,7 @@ export const CURATED_REPOS = [
         workspaceDir: "packages/brain",
         ref: "origin/main",
         maxTasks: 3,
-        note: "the brain package itself — pure-logic tests (vram, gguf, bench)",
+        note: "the brain package itself - pure-logic tests (vram, gguf, bench)",
     },
 ];
 /** Look up a curated preset by its handle. */
@@ -36,6 +36,6 @@ export function findCuratedRepo(name) {
 }
 /** A one-per-line listing of the available presets, for help/error text. */
 export function describeCuratedRepos() {
-    return CURATED_REPOS.map((r) => `  ${r.name.padEnd(10)} ${r.workspace} — ${r.note}`).join("\n");
+    return CURATED_REPOS.map((r) => `  ${r.name.padEnd(10)} ${r.workspace} - ${r.note}`).join("\n");
 }
 //# sourceMappingURL=curated-repos.js.map

package/dist/bench/health.d.ts

@@ -42,7 +42,7 @@ export declare function summarize(samples: HealthSamples): HealthSummary;
 /**
  * Begin sampling; returns a handle with stop() that returns the summary.
  * Sampling failures (no GPU, nvidia-smi missing) degrade to empty aggregates
- * rather than throwing — health is diagnostic, never a reason to fail a bench.
+ * rather than throwing - health is diagnostic, never a reason to fail a bench.
  */
 export declare function start({ intervalMs }?: {
     intervalMs?: number;

package/dist/bench/health.js

@@ -5,7 +5,7 @@ import { createCpuSampler } from "../sysmon.js";
  * System-health sampling for a benchmark run.
  *
  * A score is only trustworthy if the machine was in a comparable state when it
- * was measured — a thermal-throttled or power-capped GPU produces a slower,
+ * was measured - a thermal-throttled or power-capped GPU produces a slower,
  * lower run that says nothing about the model. So we sample GPU/CPU/RAM through
  * the run and summarise it alongside the result, and flag when nvidia-smi itself
  * reports a thermal or power slowdown (more reliable than inferring one from a
@@ -81,7 +81,7 @@ export function summarize(samples) {
 /**
  * Begin sampling; returns a handle with stop() that returns the summary.
  * Sampling failures (no GPU, nvidia-smi missing) degrade to empty aggregates
- * rather than throwing — health is diagnostic, never a reason to fail a bench.
+ * rather than throwing - health is diagnostic, never a reason to fail a bench.
  */
 export function start({ intervalMs = 1000 } = {}) {
     const samples = { gpu: [], cpu: [], ram: [] };

package/dist/bench/tasks.js

@@ -1037,7 +1037,7 @@ const contextStressTask = {
  * so the depth task stops probing rather than zeroing the whole category.
  */
 function isContextLimitError(message) {
-    // Specific to a context-length rejection — a bare "context" would misclassify
+    // Specific to a context-length rejection - a bare "context" would misclassify
     // any unrelated 500 whose body happens to mention the word.
     return /exceed|n_ctx|context (?:length|window|size)|too (?:many|long|large)|larger than|prompt is too long/i.test(message);
 }
@@ -1166,7 +1166,7 @@ const contextDepthTask = {
 };
 // ---------------------------------------------------------------- concurrency
 /**
- * Aggregate throughput with several requests in flight at once — the load a
+ * Aggregate throughput with several requests in flight at once - the load a
  * shared host actually sees when multiple chats or a model's own sub-agents hit
  * it together. Reports tokens/sec in (prompt) and out (generation) summed across
  * the concurrent requests; the score is how many returned real content, which

package/dist/cli.d.ts

@@ -3,7 +3,7 @@
  * a group factory (`createBrainCommand`) that adds straight into the main `otto`
  * program, and a `registerBrainCommands` that mounts the same verbs on a
  * standalone root program (for `bin/otto-brain` on a server without the full CLI).
- * Handlers stay pure — they return typed results wrapped by withOutput.
+ * Handlers stay pure - they return typed results wrapped by withOutput.
  */
 import { Command } from "commander";
 /** Mount every brain verb on the given command (a root program or the group). */

package/dist/cli.js

@@ -3,7 +3,7 @@
  * a group factory (`createBrainCommand`) that adds straight into the main `otto`
  * program, and a `registerBrainCommands` that mounts the same verbs on a
  * standalone root program (for `bin/otto-brain` on a server without the full CLI).
- * Handlers stay pure — they return typed results wrapped by withOutput.
+ * Handlers stay pure - they return typed results wrapped by withOutput.
  */
 import { Command } from "commander";
 import { addBenchOptions, runBenchCommand } from "./commands/bench.js";

package/dist/commands/bench.d.ts

@@ -15,6 +15,6 @@ interface BenchOptions {
     curated?: string;
 }
 export declare function addBenchOptions(cmd: Command): Command;
-export declare function runBenchCommand(options: BenchOptions, _command: Command): Promise<void>;
+export declare function runBenchCommand(options: BenchOptions, command: Command): Promise<void>;
 export {};
 //# sourceMappingURL=bench.d.ts.map

package/dist/commands/bench.js

@@ -1,5 +1,5 @@
 /**
- * `otto brain bench` — score a model's agentic coding ability on this machine.
+ * `otto brain bench` - score a model's agentic coding ability on this machine.
  * Either benchmarks an endpoint that is already serving (`--endpoint`) or loads
  * each requested model itself. A long streaming run, so it prints a formatted
  * report directly rather than going through the output layer.
@@ -11,6 +11,7 @@ import { query as queryGpu } from "../gpu.js";
 import { pickModel, scanModels } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { resolveRuntime } from "../runtime/index.js";
+import { withActivity } from "../service/activity.js";
 import { createRouter, Telemetry } from "../service/router.js";
 import { Supervisor } from "../service/supervisor.js";
 import * as bench from "../bench/index.js";
@@ -45,7 +46,14 @@ export function addBenchOptions(cmd) {
         .option("--repo-max <n>", "max mined tasks to run", "5")
         .option("--curated <name>", "run a curated mined-repo preset (needs --repo-dir); pass an unknown name to list presets");
 }
-export async function runBenchCommand(options, _command) {
+export async function runBenchCommand(options, command) {
+    // Announced so the Brain rail can show the host as busy. A benchmark loads and
+    // unloads models and drives completions through them for minutes at a time,
+    // and it is the one op most likely to be running while somebody wonders why
+    // their prompt is slow.
+    return withActivity("benchmark", { target: options.model ?? options.endpoint ?? null }, () => runBenchSuite(options, command));
+}
+async function runBenchSuite(options, _command) {
     const config = loadBrainConfig();
     const execute = options.execute !== false;
     const depths = options.depths
@@ -158,18 +166,27 @@ export async function runBenchCommand(options, _command) {
     for (const needle of needles) {
         const model = pickModel(catalog, needle);
         let profile = forModel(store, model, config.defaults);
+        // Both are recorded with the run: the fit is what says whether the profile
+        // that ran is the profile that was configured, and the calibration is what
+        // says whether the fit's own VRAM figures were measured or guessed. A score
+        // read without them is a score nobody can diagnose.
+        const calibration = getCalibration(store, model, profile);
+        let fit = null;
         const gpu = await queryGpu();
         if (gpu) {
-            const fit = vram.fitToBudget({
+            fit = vram.fitToBudget({
                 model,
                 profile,
-                calibration: getCalibration(store, model, profile),
+                calibration,
                 totalVramBytes: gpu.totalBytes,
             });
             if (!fit.adjusted && !fit.budget.fits) {
                 process.stderr.write(`\nskipping ${model.displayName}: ${fit.reason}\n`);
                 continue;
             }
+            if (fit.adjusted) {
+                process.stderr.write(`\n${model.displayName}: ${fit.reason}\n`);
+            }
             profile = fit.profile;
         }
         process.stdout.write(`\n${"=".repeat(74)}\n${model.displayName}\n${"=".repeat(74)}\n`);
@@ -205,6 +222,12 @@ export async function runBenchCommand(options, _command) {
                 gpu,
                 runtime: runtimeLabel,
                 archiveId,
+                // Straight off the supervisor rather than rebuilt here: this is the argv
+                // the child was spawned with, so it cannot drift from what actually ran.
+                args: supervisor.args,
+                fit,
+                calibration,
+                suite: { execute, concurrency, depths: depths ?? null, only, mined: Boolean(repoTasks) },
             });
             process.stderr.write(`  saved to results/${path.basename(file)}\n`);
             entries.push({ modelName: model.displayName, report });

package/dist/commands/calibrate.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain calibrate` — measure real KV bytes/token for a model and persist it,
+ * `otto brain calibrate` - measure real KV bytes/token for a model and persist it,
  * so the VRAM budget uses a measured figure instead of the (over-estimating)
  * theoretical formula.
  */

package/dist/commands/calibrate.js

@@ -4,6 +4,7 @@ import { pickModel, scanModels } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { calibrate } from "../ops/calibrate.js";
 import { resolveRuntime } from "../runtime/index.js";
+import { withActivity } from "../service/activity.js";
 import * as vram from "../vram.js";
 const calibrateSchema = {
     idField: "model",
@@ -34,7 +35,9 @@ export async function runCalibrateCommand(options, _command) {
     const catalog = scanModels(config);
     const model = pickModel(catalog, options.model ?? store.lastModelId ?? undefined);
     const profile = forModel(store, model, config.defaults);
-    const measurement = await calibrate({
+    // Announced so the Brain rail can show the host as busy: a calibrate loads the
+    // model at several context sizes and will make anything else queue behind it.
+    const measurement = await withActivity("calibrate", { target: model.displayName }, () => calibrate({
         runtime,
         model,
         profile,
@@ -46,7 +49,7 @@ export async function runCalibrateCommand(options, _command) {
             if (p.phase === "skip")
                 process.stderr.write(`  skipped ${p.contextSize}: ${p.reason}\n`);
         },
-    });
+    }));
     putCalibration(store, model, profile, measurement);
     saveProfilesStore(store);
     const gpu = await queryGpu();

package/dist/commands/catalog.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain catalog` — list the downloadable model catalog, each entry
+ * `otto brain catalog` - list the downloadable model catalog, each entry
  * annotated with whether it is already installed. The installed flag reuses the
  * authoritative catalog↔model join (enrichWithCatalog sets `catalogId` back-
  * references on scanned models), so it agrees with `scan`/`pull` and works with

package/dist/commands/config.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain config show|set` — inspect and edit the persisted config at
+ * `otto brain config show|set` - inspect and edit the persisted config at
  * $OTTO_HOME/otto-brain/config.json. Opt-in flags (`enabled`, `autoStart`) live
  * here; the Otto daemon reads them to decide whether to manage the brain.
  */

package/dist/commands/lifecycle.js

@@ -1,7 +1,7 @@
 /**
  * Service lifecycle commands. `serve` runs the brain in the foreground; `start`
  * launches it detached (the shape the Otto daemon uses to supervise a managed
- * child); `stop`/`status` operate on the pid file. All honor the opt-in config —
+ * child); `stop`/`status` operate on the pid file. All honor the opt-in config -
  * they are always explicit user actions, never auto-started.
  */
 import { spawn } from "node:child_process";

package/dist/commands/pull.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain pull <model>` — download a model from the catalog into the managed
+ * `otto brain pull <model>` - download a model from the catalog into the managed
  * models directory, using only Node's fetch (no external downloader). The catalog
  * is the same one seeded from docs/candidate-models.md. `--list-quants` shows what
  * quantizations the repo offers and `--quant <label>` downloads a specific one.

package/dist/commands/pull.js

@@ -2,6 +2,7 @@ import { loadBrainConfig, loadCatalog } from "../config/index.js";
 import { downloadRepoFiles, listRepoQuants, managedModelsDir, pullModel, resolveHfToken, } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { formatBytes } from "../models/scan.js";
+import { withActivity } from "../service/activity.js";
 const pullSchema = {
     idField: "model",
     columns: [
@@ -78,19 +79,20 @@ export async function runPullCommand(modelArg, options, _command) {
         const files = [...choice.files, ...(mmproj ? mmproj.files : [])];
         const total = choice.sizeBytes + (mmproj?.sizeBytes ?? 0);
         let lastPct = -1;
-        const written = await downloadRepoFiles({
+        const written = await withActivity("download", { target: `${model.name} (${choice.quant})` }, (activity) => downloadRepoFiles({
             repo: model.hfRepo,
             files,
             destRoot: managedModelsDir(config),
             token,
             onProgress: (p) => {
+                activity.update(total ? p.receivedBytes / total : null);
                 const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
                 if (pct !== lastPct && pct % 5 === 0) {
                     lastPct = pct;
                     process.stderr.write(`  ${model.name} ${choice.quant}: ${pct}%\r`);
                 }
             },
-        });
+        }));
         process.stderr.write("\n");
         return {
             type: "single",
@@ -105,7 +107,9 @@ export async function runPullCommand(modelArg, options, _command) {
     }
     const destRoot = managedModelsDir(config);
     let lastPct = -1;
-    const localPath = await pullModel({
+    // Announced so the Brain rail can show the download: this is the longest-
+    // running thing the brain does, and the only one measured in tens of GiB.
+    const localPath = await withActivity("download", { target: model.name }, (activity) => pullModel({
         model,
         destRoot,
         file: options.file,
@@ -113,13 +117,14 @@ export async function runPullCommand(modelArg, options, _command) {
         onProgress: (p) => {
             if (!p.totalBytes)
                 return;
+            activity.update(p.receivedBytes / p.totalBytes);
             const pct = Math.floor((p.receivedBytes / p.totalBytes) * 100);
             if (pct !== lastPct && pct % 5 === 0) {
                 lastPct = pct;
                 process.stderr.write(`  ${model.name}: ${pct}%\r`);
             }
         },
-    });
+    }));
     process.stderr.write("\n");
     return {
         type: "single",

package/dist/commands/report.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain report` — write the HTML comparison report and print a per-model
+ * `otto brain report` - write the HTML comparison report and print a per-model
  * score table (newest run per model+config).
  */
 import type { Command } from "commander";

package/dist/commands/rescore.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain rescore` — re-grade archived benchmark transcripts with the current
+ * `otto brain rescore` - re-grade archived benchmark transcripts with the current
  * scorer, no GPU used. Surfaces scorer changes against what was recorded live.
  */
 import type { Command } from "commander";

package/dist/commands/rescore.js

@@ -34,7 +34,7 @@ export async function runRescoreCommand(options, _command) {
             }
             const before = record?.tasks.find((t) => t.id === task.taskId);
             const now = `${(task.score * 100).toFixed(0)}%`;
-            const then = before ? `${(before.score * 100).toFixed(0)}%` : "—";
+            const then = before ? `${(before.score * 100).toFixed(0)}%` : "-";
             const moved = before && Math.abs(before.score - task.score) > 0.005;
             if (moved)
                 changed += 1;

package/dist/commands/runtime.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain runtime install|list` — manage the self-contained llama.cpp runtime.
+ * `otto brain runtime install|list` - manage the self-contained llama.cpp runtime.
  * `install` downloads a pinned build into $OTTO_HOME/otto-brain/runtimes so the
  * tool needs no other software; `list` shows every runtime found (managed first,
  * then LM Studio).

package/dist/commands/scan.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain scan` — list detected models with their arch, quant, size, native
+ * `otto brain scan` - list detected models with their arch, quant, size, native
  * context, vision, calibration state, and source. Returns a typed list the output
  * layer renders as a table (default), json, or yaml.
  */

package/dist/commands/scan.js

@@ -1,5 +1,6 @@
 import { getCalibration, forModel, loadBrainConfig, loadProfilesStore } from "../config/index.js";
 import { formatBytes, scanModels } from "../models/index.js";
+import { withActivity } from "../service/activity.js";
 export const scanSchema = {
     idField: "model",
     columns: [
@@ -27,7 +28,11 @@ export function addScanOptions(cmd) {
 export async function runScanCommand(options, _command) {
     const config = loadBrainConfig();
     const store = loadProfilesStore();
-    const catalog = scanModels(config, process.env, { withMetadata: options.metadata !== false });
+    // Announced because a metadata scan opens and reads the GGUF header of every
+    // model on disk, which on a large library is seconds of I/O, not milliseconds.
+    // Only the explicit `scan` command announces: the other commands call
+    // `scanModels` too, and each announcing would fight over the one record.
+    const catalog = await withActivity("scan", {}, async () => scanModels(config, process.env, { withMetadata: options.metadata !== false }));
     const rows = catalog.map((model) => {
         const profile = forModel(store, model, config.defaults);
         const md = model.metadata ?? {};

package/dist/commands/search.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain search <query>` and `otto brain repo-quants <repo>` — Hugging Face
+ * `otto brain search <query>` and `otto brain repo-quants <repo>` - Hugging Face
  * model discovery. These wrap the surface-agnostic primitives in models/hf.ts so
  * the same code serves the TUI (in-process) and the Otto app (daemon shells out
  * to `--json`, mirroring `catalog`/`scan`).

package/dist/commands/share.js

@@ -1,9 +1,9 @@
 /**
- * `otto brain share` — opt a brain into being reachable (and optionally
+ * `otto brain share` - opt a brain into being reachable (and optionally
  * configurable) by other Otto hosts. Off by default: a brain binds loopback and
  * is invisible to the network until its owner runs this. Sets the bind, the
  * access level (open on a trusted network, or a bearer key), HTTPS, and whether
- * key holders may reconfigure it. Writes $OTTO_HOME/otto-brain/config.json — the
+ * key holders may reconfigure it. Writes $OTTO_HOME/otto-brain/config.json - the
  * same fields the Otto app's Sharing UI sets, so the two stay in sync.
  */
 import { randomBytes } from "node:crypto";

package/dist/commands/sweep.d.ts

@@ -1,12 +1,12 @@
 /**
- * `otto brain sweep` — find the reasoning budget that yields the best output, and
+ * `otto brain sweep` - find the reasoning budget that yields the best output, and
  * save it to the model's profile. Guards against the thinking-model failure where
  * an unrestricted budget returns pure reasoning and no content.
  */
 import type { Command } from "commander";
 import type { AnyCommandResult } from "../output/index.js";
 export interface SweepRow {
-    budget: number | string;
+    budget: number;
     content: string;
     files: string;
     tokensPerSec: string;

package/dist/commands/sweep.js

@@ -1,12 +1,20 @@
-import { forModel, loadBrainConfig, loadProfilesStore, put, saveProfilesStore, } from "../config/index.js";
+import { forModel, formatReasoningBudget, loadBrainConfig, loadProfilesStore, put, saveProfilesStore, } from "../config/index.js";
 import { pickModel, scanModels } from "../models/index.js";
 import { CommandError } from "../output/types.js";
-import { sweep } from "../ops/sweep.js";
+import { DEFAULT_BUDGETS, sweep } from "../ops/sweep.js";
 import { resolveRuntime } from "../runtime/index.js";
+import { withActivity } from "../service/activity.js";
 const sweepSchema = {
     idField: "budget",
     columns: [
-        { header: "BUDGET", field: "budget", width: 8, align: "right" },
+        // Labelled only for the table. `budget` stays the raw number on the row, so
+        // json/yaml and --quiet still emit -1 for machine consumers.
+        {
+            header: "BUDGET",
+            field: (row) => formatReasoningBudget(row.budget),
+            width: 8,
+            align: "right",
+        },
         { header: "CONTENT", field: "content", width: 9, align: "right" },
         { header: "FILES", field: "files", width: 6, align: "right" },
         { header: "TOK/S", field: "tokensPerSec", width: 7, align: "right" },
@@ -37,20 +45,26 @@ export async function runSweepCommand(options, _command) {
     const budgets = options.budgets
         ? options.budgets.split(",").map((s) => Number(s.trim()))
         : undefined;
-    const report = await sweep({
+    // Progress lines stack, so pad to the widest label this run will print rather
+    // than a fixed width that "unrestricted" would overflow.
+    const labelWidth = Math.max(...(budgets ?? DEFAULT_BUDGETS).map((b) => formatReasoningBudget(b).length));
+    const label = (budget) => formatReasoningBudget(budget).padStart(labelWidth);
+    // Announced so the Brain rail can show the host as busy: a sweep reloads the
+    // model once per budget and owns the machine for the duration.
+    const report = await withActivity("sweep", { target: model.displayName }, () => sweep({
         runtime,
         model,
         profile,
         budgets,
         onProgress: (p) => {
             if (p.phase === "loading")
-                process.stderr.write(`  budget ${String(p.budget).padStart(5)}: loading…\n`);
+                process.stderr.write(`  budget ${label(p.budget)}: loading…\n`);
             if (p.phase === "done")
-                process.stderr.write(`  budget ${String(p.budget).padStart(5)}: done\n`);
+                process.stderr.write(`  budget ${label(p.budget)}: done\n`);
             if (p.phase === "failed")
-                process.stderr.write(`  budget ${String(p.budget).padStart(5)}: failed ${p.error}\n`);
+                process.stderr.write(`  budget ${label(p.budget)}: failed ${p.error}\n`);
         },
-    });
+    }));
     if (report.recommended !== null && report.recommended !== undefined) {
         profile.reasoningBudget = report.recommended;
         put(store, model, profile);

package/dist/commands/ui.d.ts

@@ -1,5 +1,5 @@
 /**
- * `otto brain ui` (and the bare `otto brain`) — the full-screen interactive TUI,
+ * `otto brain ui` (and the bare `otto brain`) - the full-screen interactive TUI,
  * the tool's signature experience. Gated on a TTY; falls back with guidance when
  * piped. Bypasses the output layer since it owns the whole screen.
  */

package/dist/config/index.d.ts

@@ -4,6 +4,7 @@ export { ensurePrivateDirectory, writePrivateFileAtomicSync } from "./private-fi
 export { resolveBrainPaths, packageRoot, type BrainPaths } from "./paths.js";
 export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
-export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, } from "./profiles.js";
+export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
+export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, type CalibrationInfo, type CalibrationState, type ProfileFieldDescriptor, type ProfileWarning, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -4,6 +4,7 @@ export { ensurePrivateDirectory, writePrivateFileAtomicSync } from "./private-fi
 export { resolveBrainPaths, packageRoot } from "./paths.js";
 export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
-export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, } from "./profiles.js";
+export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
+export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.js.map

package/dist/config/otto-home.js

@@ -2,7 +2,7 @@
  * Resolves $OTTO_HOME exactly as the Otto daemon does (see
  * packages/server/src/server/otto-home.ts): env override, else `~/.otto`, tilde
  * expanded, made private. Sharing this rule is what lets otto-brain's config sit
- * next to Otto's — and follow it into the dev home whenever the dev scripts export
+ * next to Otto's - and follow it into the dev home whenever the dev scripts export
  * OTTO_HOME. There is deliberately no dev-path logic here; that lives in shell.
  */
 import { homedir } from "node:os";

package/dist/config/paths.d.ts

@@ -7,6 +7,7 @@ export interface BrainPaths {
     modelsDir: string;
     runtimesDir: string;
     pidFile: string;
+    activityFile: string;
     logFile: string;
     resultsDir: string;
 }

package/dist/config/paths.js

@@ -18,6 +18,10 @@ export function resolveBrainPaths(env = process.env) {
         modelsDir: path.join(root, "models"),
         runtimesDir: path.join(root, "runtimes"),
         pidFile: path.join(root, "otto-brain.pid"),
+        // Which long-running op currently owns the host. A file rather than service
+        // state because calibrate/sweep/bench run as their own CLI processes and the
+        // 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"),
         resultsDir: path.join(root, "results"),
     };