ollanet 0.4.1 → 0.6.0

package/README.md

@@ -18,7 +18,7 @@ This started as a personal little script. I had Ollama running on a laptop on my
 
 ## Related: Finetuna
 
-**ollanet** is the client-side / network tool. On the machine that *runs* Ollama, use **[Finetuna](https://github.com/Catalyst-Forge-LLC/finetuna)** to turn a stock model into a GPU-tuned, named variant (context, batch, Modelfile, auto-tune).
+**ollanet** is the client-side / network tool. On the machine that *runs* Ollama, use **[Finetuna](https://finetuna.net)** to turn a stock model into a GPU-tuned, named variant (context, batch, Modelfile, auto-tune).
 
 Typical loop:
 
@@ -30,11 +30,14 @@ They share the same Ollama API; Finetuna shapes the models, ollanet finds and ch
 ## Features
 
 - **Discover** Ollama hosts from localhost, `config.hosts`, `OLLANET_HOSTS`, optional Tailscale, and optional LAN scan (`--lan`, off by default)
-- **Prompt** any hostname/IP/model with streaming replies
+- **Pull** a library model onto a named host (`ollanet pull studio gemma3:12b`) — the server downloads; re-pull updates
+- **Show / rm / ps** — inspect a Modelfile, delete a model (`--yes`), see what’s in VRAM. Scan marks Finetuna-style `[tuned]` names
+- **Prompt** any hostname/IP/model with streaming replies (`--file` for `.txt` / `.md`)
+- **Compare** 2–5 models on one host with the same prompt; summary table + `compares/<id>.md`
 - **Persist** chats as `responses/<hash>.json` with topic, machine, model, timestamps
 - **Continue** any thread with `--chat <hash>`
 - **Configure** per-machine defaults (model, temperature, context, …)
-- **MCP** — `ollanet mcp` exposes scan/prompt/chats as Model Context Protocol tools for agents
+- **MCP** — `ollanet mcp` exposes scan/prompt/compare/pull/show/rm/ps/chats as Model Context Protocol tools for agents
 - **Library** — `import { scanNetwork } from "ollanet"` for apps (Node 20+, not the browser)
 
 ## Use cases
@@ -44,11 +47,12 @@ The core idea: turn “I have to remember which IP has which models loaded” in
 **For agents and automation** — prefer `ollanet mcp` (stdio MCP). The same flows also work via CLI flags:
 
 - **Live model inventory / routing** — `ollanet_scan` (or `scan --json`) lists reachable hosts and models. Route each sub-task to the best host: the big-VRAM box for reasoning, the laptop for quick lookups.
+- **Put a new model on a box** — `ollanet_pull` (or `pull studio gemma3:12b`) asks that host to download from the registry. Re-pull updates. Then `show` / `ps` / `rm` manage what’s on that disk and in VRAM.
 - **Conversations that survive machines** — chats are stored by short hash with full history. Start a long thread on the GPU box, continue it later with `ollanet_prompt` + `chat_id` (or `--chat <hash>`).
 - **A “talk to any Ollama on my network” tool** — `ollanet_prompt` / `prompt … --json --no-stream`; no hard-coded endpoints.
 - **Embed in an app** — same scan + pick + call as a library. The app does not own the GPUs; it discovers them (FilePress, CLIs, Electron, a local companion for a hosted product).
 - **Fleet health and speed checks** — periodic `ollanet bench <host> --json` builds a record of which model on which machine is currently fastest (or has silently gone offline). Saved results live in `benchmarks/`.
-- **The Finetuna loop** — [Finetuna](https://github.com/Catalyst-Forge-LLC/finetuna) shapes a GPU-tuned named variant on the host; ollanet discovers and uses it from anywhere on the network.
+- **The Finetuna loop** — [Finetuna](https://finetuna.net) shapes a GPU-tuned named variant on the host; ollanet `scan` / `show` / `prompt` it from anywhere on the network. After `pull`, ollanet prints the next step (`finetuna --model …`).
 
 **For humans:**
 
@@ -115,8 +119,15 @@ ollanet scan
 # Also TCP-scan your local /24s for open Ollama ports
 ollanet scan --lan
 
+# Put a library model on a named machine (that host downloads it)
+ollanet pull studio gemma3:12b
+ollanet show studio gemma3:12b
+ollanet ps studio
+
 # Talk to a machine by name, MagicDNS name, or IP
 ollanet prompt localhost "What is MagicDNS?"
+ollanet prompt localhost --file ./notes.md
+ollanet compare studio gemma3:12b llama3.2:3b --prompt "Explain MagicDNS"
 ollanet prompt 192.168.1.50 gemma4:12b "Hello from the LAN"
 
 # Continue later
@@ -146,6 +157,7 @@ for (const s of servers) {
 |---|---|---|
 | `scanNetwork()` | localhost + config + `OLLANET_HOSTS` + Tailscale | Button / first “find servers” |
 | `scanNetwork({ lanScan: true })` | plus TCP sweep of local `/24`s on port 11434 | Checkbox; never the default scan, never on every health check |
+| `lastScan()` | last saved snapshot, no network | UI “show last inventory” |
 | `discoverHosts()` then probe yourself | candidates only, no `/api/tags` | If the app already has its own Ollama client |
 
 Pass `config` to skip the file (useful when the app already has its own config):
@@ -162,7 +174,9 @@ await scanNetwork({
 
 `runPrompt({ save: false, writeStdout: false })` is a one-shot call that does not write `~/.ollanet/responses/`.
 
-Requires **ollanet ≥ 0.4.0**. Bundlers (Vite / SvelteKit SSR):
+`pullModel({ machine, model })` asks that host to download (or update) a library model. The bits never transit ollanet. `showModel`, `removeModel({ yes: true })`, and `listLoaded` are the inspect / delete / VRAM trio.
+
+Requires **ollanet ≥ 0.4.0** (library). **Model management (`pull` / `show` / `rm` / `ps`) needs ≥ 0.5.0.** **Compare, `lastScan`, and bench `--hot` need ≥ 0.6.0.** Bundlers (Vite / SvelteKit SSR):
 
 ```ts
 // vite.config.ts
@@ -175,7 +189,12 @@ optimizeDeps: { exclude: ["ollanet"] },
 | Command | Description |
 |---|---|
 | `ollanet scan` | Probe known/discovered hosts for Ollama + list models |
-| `ollanet prompt …` | Send a prompt / continue a chat |
+| `ollanet pull <machine> <model>` | Ask that host to download / update a library model |
+| `ollanet show <machine> <model>` | Inspect Modelfile / params / capabilities (`[tuned]` when it looks like Finetuna) |
+| `ollanet rm <machine> <model> --yes` | Delete a model from that host’s disk |
+| `ollanet ps [machine]` | Models loaded in VRAM (omit machine = every discovered host) |
+| `ollanet prompt …` | Send a prompt / continue a chat (`--file` for `.txt` / `.md`) |
+| `ollanet compare …` | Same prompt on 2–5 models; summary + `compares/<id>.md` |
 | `ollanet chats` | List or inspect saved transcripts |
 | `ollanet bench …` | Benchmark models for tok/s + lightweight quality checks |
 | `ollanet mcp` | Stdio [MCP](https://modelcontextprotocol.io) server for agents |
@@ -185,6 +204,7 @@ optimizeDeps: { exclude: ["ollanet"] },
 - `--json` — machine-readable output
 - `--all` — also probe offline Tailscale peers
 - `--lan` — scan local LAN CIDRs for open Ollama ports
+- `--last` / `--cached` — print the last saved scan (no network). Written to `~/.ollanet/last-scan.json` when installed, or `./last-scan.json` in a checkout (`OLLANET_LAST_SCAN` overrides).
 
 ### `prompt` options
 
@@ -205,12 +225,70 @@ ollanet prompt --chat <hash> <prompt...>
 | `--keep-alive <value>` | Keep model loaded (`5m`, `0`, `-1`, …) |
 | `--format json\|<schema>` | JSON mode / schema |
 | `--think` / `--no-think` | Enable/disable model thinking (default **off** so replies aren’t empty on qwen3-style models) |
+| `--file <path>` | Prompt from a `.txt` or `.md` file (joins argv / stdin) |
 | `--no-stream` | Buffer the full reply |
 | `--no-save` | Do not write a transcript |
 | `--json` | Emit JSON (includes chat id when saved) |
 
 Machine can be a discovered name, hostname, FQDN, or IP (`192.168.1.50`, `host:11434`). Direct addresses work even if they were never scanned.
 
+### `compare` options
+
+```text
+ollanet compare <machine> <model> <model> [model...]
+ollanet compare <machine> <model> <model> [model...] --prompt <text>
+ollanet compare <machine> <model> <model> [model...] --file <path.txt|.md>
+```
+
+Same prompt on **2–5 models** on one host. Prints a tok/s table and writes `compares/<id>.md` (readable) plus `.json`. This is not `bench` (no fixed suite / repeats). Omit `--prompt` / `--file` to use the built-in mesh-host tasting prompt (printed on stderr when used).
+
+| Flag | Meaning |
+|---|---|
+| `--prompt` / `-p` | Prompt text (default: built-in) |
+| `--file` / `-f` | Prompt from `.txt` or `.md` |
+| `--system` | System prompt |
+| `--temperature` / `--num-predict` / `--num-ctx` / `--keep-alive` | Same as `prompt` |
+| `--think` / `--no-think` | Thinking (default off) |
+| `--unload` | Unload each model before the next (fairer tok/s) |
+| `--no-save` | Do not write `compares/*` |
+| `--json` | Full record on stdout |
+
+Override dir with `OLLANET_COMPARES_DIR`.
+
+### `pull` options
+
+```text
+ollanet pull <machine|ip> <model>
+```
+
+The named machine downloads from the Ollama registry onto **its** disk. Re-pulling the same name updates it. This is not a file upload and not a Finetuna runtime tune.
+
+| Flag | Meaning |
+|---|---|
+| `--machine <name>` | Host (same resolution as `prompt`) |
+| `--model <name>` | Model to pull |
+| `--insecure` | Allow HTTP / self-signed registries |
+| `--no-stream` | Single final response (no progress chunks) |
+| `--json` | Result JSON on stdout |
+
+Timeout default is none (large pulls can take hours). Override with `OLLAMA_PULL_TIMEOUT_MS`. After a successful pull, stderr points at [Finetuna](https://finetuna.net) for a host-side named variant.
+
+### `show` / `rm` / `ps`
+
+```text
+ollanet show <machine|ip> <model>
+ollanet rm <machine|ip> <model> --yes
+ollanet ps [machine]
+```
+
+| Flag | Meaning |
+|---|---|
+| `--yes` / `-y` | Required for `rm` unless you confirm on a TTY |
+| `--json` | Result JSON on stdout |
+| `--machine` / `--model` | Same host resolution as `prompt` |
+
+`scan` is on-disk inventory and marks `*-ctx32k` / `*-flash` / `*finetuna*` as `[tuned]`. `ps` is what’s resident. `show` reads the Modelfile so you can see a Finetuna bake from another machine.
+
 ### `chats` options
 
 - `--json` — list summary JSON
@@ -226,8 +304,13 @@ Runs a **stdio MCP server** (no extra npm deps). Cursor / Claude Desktop / any M
 
 | Tool | What it does |
 |---|---|
-| `ollanet_scan` | Discover hosts + models (`lan`, `all` optional) |
-| `ollanet_prompt` | Prompt a host or continue with `chat_id` |
+| `ollanet_scan` | Discover hosts + models (`lan`, `all`, `last` optional) |
+| `ollanet_prompt` | Prompt a host or continue with `chat_id` (`file` optional) |
+| `ollanet_compare` | Same prompt on 2–5 models (`machine`, `models`; `prompt` / `file` optional) |
+| `ollanet_pull` | Pull / update a model on a host (`machine`, `model`) |
+| `ollanet_show` | Inspect a model (`machine`, `model`) |
+| `ollanet_rm` | Delete a model (`machine`, `model`, `confirm: true`) |
+| `ollanet_ps` | Loaded models (`machine` optional) |
 | `ollanet_list_chats` | Summarize saved transcripts |
 | `ollanet_get_chat` | Load one chat (full history) |
 
@@ -252,11 +335,14 @@ Or, from a checkout: `"command": "pnpm"`, `"args": ["ollanet", "--", "mcp"]` (wi
 ollanet bench <machine|ip> [model...]
 ollanet bench <machine|ip> --all
 ollanet bench localhost gemma4:12b --runs 5 --cold-load --json
+ollanet bench localhost gemma4:12b --hot --runs 5
 ```
 
 Runs a built-in suite (`quick` default, or `--suite full`) against one or more **completion**
 models: instruction checks once, throughput case repeated (`--runs`, default 3) with
-pinned `num_predict` / `seed` / `temperature`. Reports median tok/s + spread. Under `--all`,
+pinned `num_predict` / `seed` / `temperature`. Reports median tok/s + spread.
+`--hot` discards the first throughput run and leaves models loaded so the counted
+repeats are already warm (Finetuna steady-state). Under `--all`,
 skips non-completion models (embeddings); multimodal `completion`+`vision` models stay in
 (early-stop / pass_rate handle text-suite failures). Use `--exclude-vision` to drop them.
 Saves `benchmarks/<id>.json` (or `~/.ollanet/benchmarks/` when installed).

package/dist/bench-suite.d.ts

@@ -21,5 +21,7 @@ export declare function comparabilityKey(opts: {
     temperature: number;
     think: boolean;
     numCtx: number | null;
+    /** Steady-state tok/s: first throughput run discarded, no inter-model unload. */
+    hot?: boolean;
 }): string;
 export declare function median(values: number[]): number | undefined;

package/dist/bench-suite.js

@@ -134,6 +134,7 @@ export function comparabilityKey(opts) {
         `temperature=${opts.temperature}`,
         `think=${opts.think ? 1 : 0}`,
         `num_ctx=${opts.numCtx ?? ""}`,
+        ...(opts.hot ? ["hot=1"] : []),
     ].join("|");
     return createHash("sha256").update(payload).digest("hex").slice(0, 16);
 }

package/dist/bench.js

@@ -16,11 +16,16 @@ function usage() {
   ollanet bench <machine|ip> [model...] [options]
   ollanet bench <machine|ip> --all [options]
 
+Examples:
+  ollanet bench studio gemma3:12b --runs 5
+  ollanet bench studio gemma3:12b --hot --runs 5
+
 Options:
   --all                 Every completion-capable model from /api/tags
   --exclude-vision      With --all, skip models that advertise vision
   --suite quick|full    Prompt suite (default quick)
   --runs <n>            Throughput repeats (default 3)
+  --hot                 Discard first throughput run; keep models loaded
   --warmup / --no-warmup
   --cold-load           Measure cold load via unload + /api/ps
   --num-predict <n>     Pin throughput length (default 256)
@@ -85,6 +90,8 @@ function parseArgs(argv) {
     let all = false;
     let excludeVision = false;
     let warmup = true;
+    let warmupSet = false;
+    let hot = false;
     let coldLoad = false;
     let json = false;
     let save = true;
@@ -126,10 +133,16 @@ function parseArgs(argv) {
         }
         if (arg === "--warmup") {
             warmup = true;
+            warmupSet = true;
             continue;
         }
         if (arg === "--no-warmup") {
             warmup = false;
+            warmupSet = true;
+            continue;
+        }
+        if (arg === "--hot") {
+            hot = true;
             continue;
         }
         if (arg === "--cold-load") {
@@ -221,7 +234,8 @@ function parseArgs(argv) {
         excludeVision,
         suite,
         runs,
-        warmup,
+        warmup: hot && !warmupSet ? false : warmup,
+        hot,
         coldLoad,
         json,
         save,
@@ -382,12 +396,15 @@ async function runCaseAttempt(opts) {
         };
     }
 }
+function countedAttempts(attempts) {
+    return attempts.filter((a) => !a.discarded);
+}
 function summarizeModel(cases, cold, selfJudge) {
     const throughput = cases.find((c) => c.id === "throughput");
-    const fullLen = throughput?.attempts.filter((a) => !a.error && !a.early_stop && a.tok_s != null) ?? [];
+    const counted = countedAttempts(throughput?.attempts ?? []);
+    const fullLen = counted.filter((a) => !a.error && !a.early_stop && a.tok_s != null);
     const toks = fullLen.map((a) => a.tok_s);
-    const earlyStopCount = throughput?.attempts.filter((a) => a.early_stop || (a.done_reason && a.done_reason !== "length"))
-        .length ?? 0;
+    const earlyStopCount = counted.filter((a) => a.early_stop || (a.done_reason && a.done_reason !== "length")).length;
     const checkAttempts = cases
         .filter((c) => c.role === "check")
         .flatMap((c) => c.attempts)
@@ -404,12 +421,15 @@ function summarizeModel(cases, cold, selfJudge) {
         self_judge: selfJudge,
     };
 }
-function printTable(machine, suite, runs, revision, compKey, models, skipped, coldLoad) {
+function printTable(machine, suite, runs, revision, compKey, models, skipped, coldLoad, hot) {
     const lines = [];
-    lines.push(`Bench: ${models.length} completion model(s) × suite=${suite} × runs=${runs}`);
+    lines.push(`Bench: ${models.length} completion model(s) × suite=${suite} × runs=${runs}` +
+        (hot ? " (hot: first discarded)" : ""));
     lines.push(`comparability_key=${compKey}   suite_revision=${revision}   timeout: ${BENCH_TIMEOUT_MS}ms/case`);
     if (coldLoad)
         lines.push("Cold-load: on");
+    if (hot)
+        lines.push("Hot: first throughput run discarded; models stay loaded");
     lines.push("");
     const header = coldLoad
         ? pad("Model", MODEL_COL) +
@@ -462,6 +482,8 @@ function printTable(machine, suite, runs, revision, compKey, models, skipped, co
             notes.push(m.error.slice(0, 60));
         if (m.summary.early_stop_count > 0)
             notes.push(`${m.summary.early_stop_count}× early-stop`);
+        if (hot)
+            notes.push("hot");
         if (m.summary.self_judge)
             notes.push("self-judge");
         const load = m.summary.load_ms != null && m.summary.load_ms > 0
@@ -590,11 +612,13 @@ export async function main() {
         temperature: 0,
         think: baseSettings.think === true,
         numCtx: baseSettings.num_ctx ?? null,
+        hot: parsed.hot,
     });
     const suiteCases = getSuiteCases(parsed.suite);
+    const throughputReps = parsed.runs + (parsed.hot ? 1 : 0);
     const caseCount = selected.length *
         (suiteCases.filter((c) => c.role !== "throughput").length +
-            suiteCases.filter((c) => c.role === "throughput").length * parsed.runs);
+            suiteCases.filter((c) => c.role === "throughput").length * throughputReps);
     if (!parsed.json) {
         const skipBits = [
             skipped.filter((s) => s.reason === "non-completion").length
@@ -606,16 +630,22 @@ export async function main() {
         ].filter(Boolean);
         console.error(`Bench: ${selected.length} completion model(s)` +
             (skipBits.length ? ` (skipped ${skipBits.join(", ")})` : "") +
-            ` × suite=${parsed.suite} × runs=${parsed.runs}`);
+            ` × suite=${parsed.suite} × runs=${parsed.runs}` +
+            (parsed.hot ? " (hot: +1 discarded)" : ""));
         console.error(`Cases: ~${caseCount} chat calls   timeout: ${BENCH_TIMEOUT_MS}ms/case` +
             `   worst-case ceiling: ~${Math.ceil((caseCount * BENCH_TIMEOUT_MS) / 60000)}m if every call times out`);
-        if (!isLoopback(host)) {
-            console.error(`Note: benchmarking unloads models on ${machineLabel} between runs` +
-                (parsed.coldLoad ? " (and for --cold-load)" : "") +
-                ".");
+        if (!parsed.hot && !isLoopback(host) && (selected.length >= 2 || parsed.coldLoad)) {
+            const bits = [
+                selected.length >= 2 ? "unloads each model before the next" : "",
+                parsed.coldLoad ? "unloads for --cold-load" : "",
+            ].filter(Boolean);
+            console.error(`Note: benchmarking ${bits.join(" and ")} on ${machineLabel}.`);
         }
         console.error("Proceeding…");
     }
+    if (parsed.hot) {
+        console.error("Hot: discarding the first throughput run; models stay loaded (no unload between models).");
+    }
     if (parsed.settings.think === true) {
         for (const name of selected) {
             const caps = await fetchCapabilities(baseUrl, name);
@@ -665,18 +695,22 @@ export async function main() {
         let modelError;
         for (const caseDef of suiteCases) {
             const attempts = [];
-            const reps = caseDef.role === "throughput" ? parsed.runs : 1;
-            for (let r = 1; r <= reps; r += 1) {
+            const discardFirst = parsed.hot && caseDef.role === "throughput";
+            const reps = caseDef.role === "throughput" ? parsed.runs + (discardFirst ? 1 : 0) : 1;
+            for (let i = 0; i < reps; i += 1) {
+                const discarded = discardFirst && i === 0;
                 const attempt = await runCaseAttempt({
                     baseUrl,
                     model,
                     caseDef,
-                    run: r,
+                    run: discarded ? 0 : discardFirst ? i : i + 1,
                     settings: baseSettings,
                     throughputNumPredict: parsed.throughputNumPredict,
                     judgeModel,
                     selfJudge,
                 });
+                if (discarded)
+                    attempt.discarded = true;
                 attempts.push(attempt);
                 if (attempt.error) {
                     anyError = true;
@@ -717,8 +751,9 @@ export async function main() {
         });
         if (parsed.failFast && modelError)
             break;
-        // Unload before next model when ≥2 models remain after this one / multi-model run
-        if (selected.length >= 2 && mi < selected.length - 1) {
+        // Unload before next model when ≥2 models remain after this one / multi-model run.
+        // --hot keeps weights resident so the discarded first shot warms the rest.
+        if (!parsed.hot && selected.length >= 2 && mi < selected.length - 1) {
             try {
                 await ollamaUnload(baseUrl, model, BENCH_TIMEOUT_MS);
                 await waitUntilUnloaded(baseUrl, model, UNLOAD_WAIT_MS);
@@ -755,6 +790,7 @@ export async function main() {
             throughput_num_predict: parsed.throughputNumPredict,
             num_ctx: baseSettings.num_ctx ?? null,
             warmup: parsed.warmup,
+            hot: parsed.hot,
             cold_load: parsed.coldLoad,
             think: baseSettings.think === true,
             bench_timeout_ms: BENCH_TIMEOUT_MS,
@@ -778,7 +814,7 @@ export async function main() {
     }
     else {
         process.stdout.write("\n");
-        printTable(machineLabel, parsed.suite, parsed.runs, revision, compKey, modelResults, skipped, parsed.coldLoad);
+        printTable(machineLabel, parsed.suite, parsed.runs, revision, compKey, modelResults, skipped, parsed.coldLoad, parsed.hot);
         if (parsed.save)
             console.error(`benchmarks dir: ${benchmarksDir()}`);
     }

package/dist/cli.d.ts

@@ -4,6 +4,10 @@
  *
  *   ollanet scan
  *   ollanet prompt <machine-or-ip> "hello"
+ *   ollanet pull <machine> <model>
+ *   ollanet show <machine> <model>
+ *   ollanet rm <machine> <model> --yes
+ *   ollanet ps [machine]
  *   ollanet chats
  */
 export {};

package/dist/cli.js

@@ -4,6 +4,10 @@
  *
  *   ollanet scan
  *   ollanet prompt <machine-or-ip> "hello"
+ *   ollanet pull <machine> <model>
+ *   ollanet show <machine> <model>
+ *   ollanet rm <machine> <model> --yes
+ *   ollanet ps [machine]
  *   ollanet chats
  */
 const HELP = `ollanet — Ollama over your network
@@ -12,9 +16,15 @@ Discover Ollama hosts on localhost, your LAN, Tailscale, or any IP/hostname
 you can reach — then chat with hash-addressed transcripts.
 
 Usage:
-  ollanet scan [--json] [--all] [--lan]
+  ollanet scan [--json] [--all] [--lan] [--last]
   ollanet prompt <machine|ip> [model] <prompt...>
   ollanet prompt --chat <hash> <prompt...>
+  ollanet prompt <machine|ip> --file <path.txt|.md>
+  ollanet compare <machine> <model> <model> [model...] [--prompt <text> | --file <path>]
+  ollanet pull <machine|ip> <model>
+  ollanet show <machine|ip> <model>
+  ollanet rm <machine|ip> <model> --yes
+  ollanet ps [machine]
   ollanet chats [--json] [--id <hash>]
   ollanet bench <machine|ip> [model...] [--all] [options]
   ollanet mcp
@@ -22,18 +32,27 @@ Usage:
 Examples:
   ollanet scan
   ollanet scan --lan
+  ollanet scan --last            # print the last saved scan (no network)
   ollanet prompt localhost "What is MagicDNS?"
-  ollanet prompt 192.168.1.50 gemma4:12b "Hello"
+  ollanet prompt localhost --file ./notes.md
+  ollanet compare studio gemma3:12b llama3.2:3b
+  ollanet compare studio gemma3:12b llama3.2:3b --prompt "Explain MagicDNS"
   ollanet prompt --chat a1b2c3d4e5f6 "Tell me more"
+  ollanet pull studio gemma3:12b
+  ollanet show studio gemma4-ctx32k
+  ollanet rm studio llama3.2:1b --yes
+  ollanet ps studio
   ollanet chats
   ollanet bench localhost --all
   ollanet bench localhost llama3.2:1b --runs 3
+  ollanet bench localhost gemma3:12b --hot --runs 5
   ollanet mcp                  # stdio MCP server for agents
 
 Config: ~/.ollanet/config.json when installed, ./config.json in a checkout
         (override with OLLANET_CONFIG)
 Hosts:  config.hosts, OLLANET_HOSTS, optional Tailscale + --lan
 Chats:  ~/.ollanet/responses or ./responses (override with OLLANET_RESPONSES_DIR)
+Scan:   ~/.ollanet/last-scan.json or ./last-scan.json (override with OLLANET_LAST_SCAN)
 `;
 async function main() {
     // pnpm/npm often forward a bare `--`; ignore it.
@@ -73,6 +92,37 @@ async function main() {
             await run();
             return;
         }
+        case "pull":
+        case "download": {
+            const { main: run } = await import("./pull.js");
+            await run();
+            return;
+        }
+        case "show":
+        case "inspect": {
+            const { main: run } = await import("./show.js");
+            await run();
+            return;
+        }
+        case "rm":
+        case "delete": {
+            const { main: run } = await import("./rm.js");
+            await run();
+            return;
+        }
+        case "ps":
+        case "loaded": {
+            const { main: run } = await import("./ps.js");
+            await run();
+            return;
+        }
+        case "compare":
+        case "vs":
+        case "h2h": {
+            const { main: run } = await import("./compare.js");
+            await run();
+            return;
+        }
         case "bench":
         case "benchmark": {
             const { main: run } = await import("./bench.js");

package/dist/compare-store.d.ts

@@ -0,0 +1,8 @@
+import type { CompareRecord } from "./compare.js";
+export declare function comparesDir(): string;
+export declare function newCompareId(): string;
+export declare function renderCompareMarkdown(record: CompareRecord): string;
+export declare function saveCompare(record: CompareRecord): Promise<{
+    json: string;
+    md: string;
+}>;

package/dist/compare-store.js

@@ -0,0 +1,55 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultComparesDir } from "./paths.js";
+export function comparesDir() {
+    return process.env.OLLANET_COMPARES_DIR ?? defaultComparesDir();
+}
+export function newCompareId() {
+    return randomBytes(6).toString("hex");
+}
+function tokLabel(n) {
+    return n == null || !Number.isFinite(n) ? "—" : n.toFixed(1);
+}
+export function renderCompareMarkdown(record) {
+    const lines = [
+        `# Compare ${record.id}`,
+        "",
+        `- **host:** ${record.machine} (${record.endpoint})`,
+        `- **when:** ${record.created_at}`,
+        `- **models:** ${record.results.map((r) => r.model).join(", ")}`,
+        ...(record.default_prompt
+            ? ["- **prompt:** default (override with --prompt / --file)"]
+            : []),
+        "",
+        "## Prompt",
+        "",
+        record.prompt.trimEnd(),
+        "",
+    ];
+    if (record.system) {
+        lines.push("## System", "", record.system.trimEnd(), "");
+    }
+    for (const r of record.results) {
+        lines.push(`## ${r.model}`, "");
+        if (r.error) {
+            lines.push(`- **error:** ${r.error}`, "");
+            continue;
+        }
+        lines.push(`- **tok/s:** ${tokLabel(r.tok_s)}`, `- **tokens:** ${r.eval_count ?? "—"}`, `- **wall:** ${r.wall_ms != null ? `${(r.wall_ms / 1000).toFixed(2)}s` : "—"}`, `- **done:** ${r.done_reason ?? "—"}`, "");
+        if (r.thinking) {
+            lines.push("### Thinking", "", r.thinking.trimEnd(), "");
+        }
+        lines.push(r.content?.trimEnd() || "_(empty reply)_", "");
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function saveCompare(record) {
+    const dir = comparesDir();
+    await mkdir(dir, { recursive: true });
+    const json = path.join(dir, `${record.id}.json`);
+    const md = path.join(dir, `${record.id}.md`);
+    await writeFile(json, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    await writeFile(md, renderCompareMarkdown(record), "utf8");
+    return { json, md };
+}

package/dist/compare.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Head-to-head: one prompt, 2–5 models on the same host.
+ *
+ *   ollanet compare studio gemma3:12b llama3.2:3b --prompt "Explain MagicDNS"
+ *   ollanet compare studio m1 m2 --file task.md
+ */
+import { type AppConfig, type GenerateSettings } from "./config.js";
+/** Used when --prompt, --file, and stdin are all omitted. */
+export declare const DEFAULT_COMPARE_PROMPT: string;
+export interface CompareModelResult {
+    model: string;
+    content?: string;
+    thinking?: string;
+    tok_s?: number;
+    eval_count?: number;
+    eval_duration?: number;
+    total_duration?: number;
+    load_duration?: number;
+    wall_ms?: number;
+    done_reason?: string;
+    error?: string;
+}
+export interface CompareRecord {
+    id: string;
+    created_at: string;
+    machine: string;
+    endpoint: string;
+    prompt: string;
+    /** True when the built-in default prompt was used. */
+    default_prompt: boolean;
+    system?: string;
+    results: CompareModelResult[];
+    files?: {
+        json: string;
+        md: string;
+    };
+}
+export interface CompareOptions {
+    machine: string;
+    models: string[];
+    prompt?: string;
+    file?: string;
+    settings?: GenerateSettings;
+    save?: boolean;
+    unload?: boolean;
+    writeStdout?: boolean;
+    quiet?: boolean;
+    config?: Partial<AppConfig>;
+    timeoutMs?: number;
+}
+export declare function runCompare(opts: CompareOptions): Promise<CompareRecord>;
+export declare function main(): Promise<void>;