turbollm 1.3.2 → 1.4.0

package/dist/cli.js

@@ -2,9 +2,9 @@
 
 // src/cli.ts
 import { spawn as spawn5 } from "child_process";
-import { openSync as openSync3, readFileSync as readFileSync10 } from "fs";
+import { openSync as openSync3, readFileSync as readFileSync11 } from "fs";
 import { serve } from "@hono/node-server";
-import { dirname as dirname9, join as join21 } from "path";
+import { dirname as dirname9, join as join22 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/config.ts
@@ -3525,8 +3525,8 @@ function gpuBudgetMb(sys, p) {
   return sys.gpus.reduce((sum, g) => sum + (g.vramMb || 0), 0);
 }
 function estimateVram(p, m, sys) {
-  const totalVramMb = gpuBudgetMb(sys, p);
-  if (totalVramMb === 0) return { estMb: 0, totalVramMb: 0, pct: 0, verdict: "cpu" };
+  const totalVramMb2 = gpuBudgetMb(sys, p);
+  if (totalVramMb2 === 0) return { estMb: 0, totalVramMb: 0, pct: 0, verdict: "cpu" };
   const sizeMb = m.sizeBytes / 1e6;
   const blocks = m.blockCount || 1;
   const gpuFrac = m.moe ? 1 - 0.85 * (p.nCpuMoe / blocks) : Math.min(p.ngl, blocks) / blocks;
@@ -3536,9 +3536,9 @@ function estimateVram(p, m, sys) {
   const kvMb = kvElems * kvBytesPerElem(p.kvTypeK) / 1e6 * (p.kvUnified ? 1 : Math.max(1, p.parallel));
   const mmprojMb = p.useMmproj && p.mmprojGpu && m.mmprojPath ? 600 : 0;
   const estMb = Math.round(weightsMb + kvMb + 800 + mmprojMb);
-  const pct = estMb / totalVramMb;
+  const pct = estMb / totalVramMb2;
   const verdict = pct <= 0.8 ? "fits" : pct <= 0.95 ? "tight" : "overflow";
-  return { estMb, totalVramMb, pct, verdict };
+  return { estMb, totalVramMb: totalVramMb2, pct, verdict };
 }
 function deriveDefault(m, sys) {
   const hasGpu = sys.gpus.length > 0;
@@ -4609,6 +4609,25 @@ var PREFILL_GRACE_MS = 8e3;
 var TOTAL_BUDGET_MS = 20 * 6e4;
 var OOM_RE = /out of memory|cudaMalloc|failed to allocate|unable to allocate|device not ready|CUDA error/i;
 var CHARS_PER_TOKEN = 4;
+var QUALITY_KV = ["f16", "q8_0", "turbo4"];
+var VRAM_HEADROOM_MB = 1024;
+var OUTPUT_TIE = 0.05;
+var KV_SPREAD_MIN = 1024;
+var KV_BYTES = {
+  f32: 4,
+  f16: 2,
+  bf16: 2,
+  q8_0: 1,
+  q8_1: 1,
+  q5_0: 0.625,
+  q5_1: 0.625,
+  q4_0: 0.5,
+  q4_1: 0.5,
+  iq4_nl: 0.5,
+  turbo4: 0.5,
+  turbo3: 0.375,
+  turbo2: 0.25
+};
 var BenchError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -4713,13 +4732,24 @@ var BenchRunner = class {
     const caps = active?.capabilities ?? { flags: [], kvTypes: [] };
     const saved = this.store.snapshot().modelProfiles[modelKey];
     const defaults = this.store.snapshot().modelDefaults;
-    const baseProfile = resolveProfile(entry, sys, saved, base2, defaults);
+    const resolved = resolveProfile(entry, sys, saved, base2, defaults);
+    const baseProfile = { ...resolved, speculative: "off", mtpHeadPath: "", draftModelPath: "", useMmproj: false };
     const results = [];
     let best = null;
-    if (!entry.moe) {
-      best = await this.denseSearch(entry, sys, baseProfile, caps, results);
-    } else {
-      best = await this.moeSearch(entry, sys, baseProfile, caps, results);
+    const kvCandidates = pickKvQuants(baseProfile.kvTypeK, caps.kvTypes);
+    let kvToTune = kvCandidates.slice(0, 1);
+    if (sys.gpus.length > 0 && kvCandidates.length > 1) {
+      const spread = await this.calibrateKvSpread(entry, sys, baseProfile, caps, kvCandidates, results);
+      kvToTune = decideKvToBench(spread, kvCandidates);
+      const swing = spread < 0 ? "unknown" : spread >= Number.MAX_SAFE_INTEGER ? "huge" : `${Math.round(spread)} MB`;
+      this.state = { ...this.state, step: `KV cache swing ${swing} \u2192 tuning ${kvToTune.join(" + ")}`, candidates: results };
+    }
+    for (let i = 0; i < kvToTune.length && !this.cancelled && Date.now() <= this.deadline; i++) {
+      const kv = kvToTune[i];
+      const kvBase = { ...baseProfile, kvTypeK: kv, kvTypeV: kv };
+      const found = entry.moe ? await this.moeSearch(entry, sys, kvBase, caps, results) : await this.denseSearch(entry, sys, kvBase, caps, results);
+      if (found && (!best || betterBySpeed(found.cand, best.cand))) best = found;
+      if (best) this.state = { ...this.state, bestTps: best.cand.tps ?? void 0 };
     }
     await this.manager.stopAndWait().catch(() => {
     });
@@ -4744,6 +4774,7 @@ var BenchRunner = class {
         result: {
           params: best.cand.params,
           tps: best.cand.tps ?? 0,
+          prefillTps: best.cand.prefillTps,
           ttftMs: best.cand.ttftMs ?? 0,
           vramMb: best.cand.vramMb,
           // The full sampling that Save will persist (winning profile, card values merged in) so
@@ -4764,101 +4795,151 @@ var BenchRunner = class {
       this.state = { running: false, modelKey, done: true, error: err3, candidates: results };
     }
   }
-  /** Binary search over ngl to find the highest number of GPU layers that does not OOM.
-   *  For dense models, more GPU layers = faster (monotonically), so the optimal is simply
-   *  the maximum ngl that fits in VRAM. O(log blockCount) trials — far more precise than
-   *  the old fixed-set sweep. CPU-only machines skip straight to ngl=0. */
+  /** Dense models: pin `ngl` by VRAM probing (Phase 1), then run the full bench once (Phase 2).
+   *  More GPU layers = faster, monotonically, up to the no-spill edge — so the best ngl is the
+   *  HIGHEST whose absolute VRAM still leaves the ≤1 GB headroom. Whether a config fits/spills is a
+   *  LOAD-time property, so we find that ngl with cheap load-and-read-VRAM probes (no generation),
+   *  and only measure t/s at the winner. CPU-only machines skip straight to ngl=0. */
   async denseSearch(entry, sys, base2, caps, results) {
-    const hasGpu = sys.gpus.length > 0;
-    if (!hasGpu) {
-      const label = "ngl=0 (CPU-only)";
-      const cand = await this.measure(entry, sys, { ...base2, ngl: 0 }, caps, label, label);
-      results.push(cand);
-      this.state = { ...this.state, candidates: results };
-      if (cand.outcome === "ok") return { cand, profile: { ...base2, ngl: 0 } };
-      return null;
-    }
-    const hi0 = entry.blockCount > 0 ? entry.blockCount : 99;
-    let lo = 0, hi = hi0;
-    let best = null;
-    while (lo <= hi && !this.cancelled && Date.now() <= this.deadline) {
-      const mid = Math.floor((lo + hi) / 2);
-      const label = `ngl=${mid}`;
-      const stepPrefix = `Trial ${results.length + 1}: ${label} (range ${lo}\u2013${hi})`;
-      this.state = { ...this.state, step: `${stepPrefix}\u2026`, candidates: results };
-      const profile = { ...base2, ngl: mid };
-      const cand = await this.measure(entry, sys, profile, caps, label, stepPrefix);
-      results.push(cand);
-      this.state = { ...this.state, candidates: results };
-      await this.settleGpu();
-      if (cand.outcome === "ok" && cand.tps !== null) {
-        if (!best || cand.tps > (best.cand.tps ?? 0)) best = { cand, profile };
-        this.state = { ...this.state, bestTps: best.cand.tps ?? void 0 };
-        lo = mid + 1;
-      } else if (cand.outcome === "oom") {
-        hi = mid - 1;
-      } else {
-        hi = mid - 1;
+    let bestNgl = 0;
+    if (sys.gpus.length > 0) {
+      const hi0 = entry.blockCount > 0 ? entry.blockCount : 99;
+      let lo = 0, hi = hi0;
+      bestNgl = null;
+      while (lo <= hi && !this.cancelled && Date.now() <= this.deadline) {
+        const mid = Math.floor((lo + hi) / 2);
+        this.state = { ...this.state, step: `KV ${base2.kvTypeK}: probing ngl=${mid} (range ${lo}\u2013${hi})\u2026`, candidates: results };
+        const probe2 = await this.probeVram(entry, sys, { ...base2, ngl: mid }, caps);
+        this.pushProbe(results, base2, "ngl", mid, probe2);
+        await this.settleGpu();
+        if (probe2.outcome === "ok" && !overHeadroom(probe2.vramAbsMb, sys)) {
+          bestNgl = mid;
+          lo = mid + 1;
+        } else {
+          hi = mid - 1;
+        }
       }
     }
-    return best ? await this.confirmPeak(entry, sys, base2, caps, results, best, "ngl", 0) : null;
+    if (bestNgl === null) return null;
+    return this.benchAt(entry, sys, { ...base2, ngl: bestNgl }, caps, results, `ngl=${bestNgl}`);
   }
-  /** Binary search over nCpuMoe to find the minimum number of MoE experts kept on CPU
-   *  that still fits in VRAM. Fewer CPU experts = more on GPU = faster; we want the
-   *  minimum that doesn't OOM. O(log blockCount) trials. */
+  /** MoE models: pin `nCpuMoe` by VRAM probing (Phase 1), then run the full bench once (Phase 2).
+   *  Fewer CPU experts = more on GPU = faster, so the best is the LOWEST nCpuMoe whose absolute VRAM
+   *  still leaves the ≤1 GB headroom. Found with cheap load-and-read-VRAM probes (no generation);
+   *  t/s is measured only at the winner. */
   async moeSearch(entry, sys, base2, caps, results) {
     const derived = deriveDefault(entry, sys);
     const maxN = entry.blockCount > 0 ? entry.blockCount : derived.nCpuMoe || 0;
     let lo = 0, hi = maxN;
-    let best = null;
+    let bestN = null;
     while (lo <= hi && !this.cancelled && Date.now() <= this.deadline) {
       const mid = Math.floor((lo + hi) / 2);
-      const label = `nCpuMoe=${mid}`;
-      const stepPrefix = `Trial ${results.length + 1}: ${label} (range ${lo}\u2013${hi})`;
-      this.state = { ...this.state, step: `${stepPrefix}\u2026`, candidates: results };
-      const profile = { ...base2, nCpuMoe: mid };
-      const cand = await this.measure(entry, sys, profile, caps, label, stepPrefix);
-      results.push(cand);
-      this.state = { ...this.state, candidates: results };
+      this.state = { ...this.state, step: `KV ${base2.kvTypeK}: probing nCpuMoe=${mid} (range ${lo}\u2013${hi})\u2026`, candidates: results };
+      const probe2 = await this.probeVram(entry, sys, { ...base2, nCpuMoe: mid }, caps);
+      this.pushProbe(results, base2, "nCpuMoe", mid, probe2);
       await this.settleGpu();
-      if (cand.outcome === "oom" || overVram(cand.vramMb, sys)) {
+      if (probe2.outcome === "oom" || overHeadroom(probe2.vramAbsMb, sys)) {
         lo = mid + 1;
-      } else if (cand.outcome === "ok" && cand.tps !== null) {
-        if (!best || cand.tps > (best.cand.tps ?? 0)) best = { cand, profile };
-        this.state = { ...this.state, bestTps: best.cand.tps ?? void 0 };
+      } else if (probe2.outcome === "ok") {
+        bestN = mid;
         hi = mid - 1;
       } else {
         lo = mid + 1;
       }
     }
-    return best ? await this.confirmPeak(entry, sys, base2, caps, results, best, "nCpuMoe", maxN) : null;
-  }
-  /** Spill correction (unimodal throughput). The binary search picks the config that "fits", but a
-   *  config that overflows VRAM into shared memory passes the fit/prefill check yet is PCIe-bottlenecked
-   *  — so t/s actually PEAKS at the no-spill edge and drops once spilling. After the search, step ONE
-   *  toward LESS GPU (moe: +1 expert on CPU; dense: -1 GPU layer) and keep it only while it's faster:
-   *  if the pick was spilling, this follows the curve up to the real peak; if not, it confirms the pick
-   *  in one extra trial. */
-  async confirmPeak(entry, sys, base2, caps, results, best, knob, maxNCpuMoe) {
-    for (let guard = 0; guard < 8 && !this.cancelled && Date.now() <= this.deadline; guard++) {
-      const cur = knob === "nCpuMoe" ? best.cand.params.nCpuMoe : best.cand.params.ngl;
-      const next = knob === "nCpuMoe" ? cur + 1 : cur - 1;
-      if (knob === "nCpuMoe" ? next > maxNCpuMoe : next < 0) break;
-      const label = `${knob}=${next}`;
-      this.state = { ...this.state, step: `Confirming ${label} (spill check)\u2026`, candidates: results };
-      const profile = knob === "nCpuMoe" ? { ...base2, nCpuMoe: next } : { ...base2, ngl: next };
-      const cand = await this.measure(entry, sys, profile, caps, label, `Confirming ${label}`);
-      results.push(cand);
-      this.state = { ...this.state, candidates: results };
-      await this.settleGpu();
-      if (cand.outcome === "ok" && cand.tps !== null && cand.tps > (best.cand.tps ?? 0)) {
-        best = { cand, profile };
-        this.state = { ...this.state, bestTps: best.cand.tps ?? void 0 };
-      } else {
-        break;
-      }
+    if (bestN === null) return null;
+    return this.benchAt(entry, sys, { ...base2, nCpuMoe: bestN }, caps, results, `nCpuMoe=${bestN}`);
+  }
+  /** Measure how much the KV-cache QUANT swings VRAM at this context — so we tune only the quant(s)
+   *  that matter instead of sweeping all. Two cheap probes (largest vs smallest candidate) at ONE
+   *  shared offload: their VRAM difference is exactly the KV-size difference (weights + overhead are
+   *  identical at the same offload), valid for any architecture. Returns that swing in MB scaled to
+   *  the full model, `Number.MAX_SAFE_INTEGER` if even the largest quant won't load (cache enormous
+   *  → definitely the big-KV regime), or -1 if it couldn't be sized at all. */
+  async calibrateKvSpread(entry, sys, base2, caps, candidates, results) {
+    const big = kvLargest(candidates);
+    const small = kvSmallest(candidates);
+    if (big === small) return 0;
+    const blocks = entry.blockCount > 0 ? entry.blockCount : 32;
+    const moeMax = entry.blockCount > 0 ? entry.blockCount : deriveDefault(entry, sys).nCpuMoe || 0;
+    const refNgl = Math.max(1, Math.floor(blocks / 4));
+    const refOffload = entry.moe ? { nCpuMoe: moeMax, ngl: 99 } : { ngl: refNgl };
+    const knob = entry.moe ? "nCpuMoe" : "ngl";
+    const knobVal = entry.moe ? moeMax : refNgl;
+    this.state = { ...this.state, step: `Sizing the KV cache (${big} vs ${small})\u2026`, candidates: results };
+    const pBig = await this.probeVram(entry, sys, { ...base2, kvTypeK: big, kvTypeV: big, ...refOffload }, caps);
+    this.pushProbe(results, { ...base2, kvTypeK: big, ...refOffload }, knob, knobVal, pBig);
+    await this.settleGpu();
+    const pSmall = await this.probeVram(entry, sys, { ...base2, kvTypeK: small, kvTypeV: small, ...refOffload }, caps);
+    this.pushProbe(results, { ...base2, kvTypeK: small, ...refOffload }, knob, knobVal, pSmall);
+    await this.settleGpu();
+    if (pBig.outcome !== "ok" || pBig.vramAbsMb === null) return Number.MAX_SAFE_INTEGER;
+    if (pSmall.outcome !== "ok" || pSmall.vramAbsMb === null) return -1;
+    let spread = pBig.vramAbsMb - pSmall.vramAbsMb;
+    if (!entry.moe) spread = spread * (blocks / refNgl);
+    return Math.max(0, spread);
+  }
+  /** A cheap VRAM probe (Phase 1 of a search): load the candidate, wait for readiness — by which
+   *  point the weights, the full KV cache, AND the compute buffers are all allocated — read the
+   *  absolute GPU VRAM in use, then stop. NO prefill, NO generation. The offload param is decided
+   *  from this alone: whether a config fits-with-headroom or spills is a load-time property, so
+   *  measuring t/s at every search step would be wasted — we bench ONCE, at the chosen config. */
+  async probeVram(entry, sys, profile, caps) {
+    const active = this.registry.active();
+    if (!active) return { outcome: "crash", vramAbsMb: null };
+    const testDeadline = Math.min(Date.now() + READY_TIMEOUT_MS + 5e3, this.deadline);
+    const opts = {
+      engine: active,
+      model: { key: entry.key, name: entry.name, quant: entry.quant, ctx: profile.ctx, vision: entry.vision },
+      modelPath: entry.path,
+      extraArgs: profileToArgs(profile, entry, caps, sys.cores)
+    };
+    try {
+      await this.manager.start(opts);
+    } catch {
+      return { outcome: "crash", vramAbsMb: null };
+    }
+    const outcome = await this.awaitReady(testDeadline);
+    let vramAbsMb = null;
+    if (outcome === "ok") {
+      await sleep2(800);
+      vramAbsMb = await readNvidiaVramMb();
     }
-    return best;
+    await this.manager.stopAndWait().catch(() => {
+    });
+    return { outcome, vramAbsMb };
+  }
+  /** Record a VRAM-probe trial in the candidate list (tps/prefill are null — nothing was generated;
+   *  only the load outcome and absolute VRAM are known). */
+  pushProbe(results, base2, knob, value, probe2) {
+    results.push({
+      label: `probe ${knob}=${value}`,
+      params: {
+        ctx: base2.ctx,
+        ngl: knob === "ngl" ? value : base2.ngl,
+        nCpuMoe: knob === "nCpuMoe" ? value : base2.nCpuMoe,
+        parallel: base2.parallel,
+        kvTypeK: base2.kvTypeK,
+        flashAttn: base2.flashAttn
+      },
+      outcome: probe2.outcome,
+      tps: null,
+      prefillTps: null,
+      ttftMs: null,
+      vramMb: null,
+      vramAbsMb: probe2.vramAbsMb
+    });
+    this.state = { ...this.state, candidates: results };
+  }
+  /** Phase 2: the single full prefill + t/s benchmark, at the offload the VRAM probe chose. Pushes
+   *  the candidate and returns it as this KV quant's winner (null if the final measurement faulted). */
+  async benchAt(entry, sys, profile, caps, results, label) {
+    this.state = { ...this.state, step: `KV ${profile.kvTypeK}: measuring best (${label})\u2026`, candidates: results };
+    const cand = await this.measure(entry, sys, profile, caps, label, `Measuring ${label}`);
+    results.push(cand);
+    this.state = { ...this.state, candidates: results, bestTps: cand.tps ?? this.state.bestTps };
+    await this.settleGpu();
+    return cand.outcome === "ok" && cand.tps !== null ? { cand, profile } : null;
   }
   /** The measurement primitive (spec 09 §1): launch the candidate, detect
    *  ready/timeout/crash/oom, then warm up + one measured request. Never throws —
@@ -4872,7 +4953,7 @@ var BenchRunner = class {
       kvTypeK: profile.kvTypeK,
       flashAttn: profile.flashAttn
     };
-    const fail = (outcome2) => ({ label, params, outcome: outcome2, tps: null, ttftMs: null, vramMb: null });
+    const fail = (outcome2) => ({ label, params, outcome: outcome2, tps: null, prefillTps: null, ttftMs: null, vramMb: null, vramAbsMb: null });
     const phase = (p) => {
       this.state = { ...this.state, step: `${stepPrefix} \u2014 ${p}` };
     };
@@ -4921,7 +5002,7 @@ var BenchRunner = class {
     });
     if ("fault" in measured) return fail(measured.fault);
     const vramMb = vramBefore !== null && vramAfter !== null ? Math.max(0, vramAfter - vramBefore) : vramAfter;
-    return { label, params, outcome: "ok", tps: measured.tps, ttftMs: measured.ttftMs, vramMb };
+    return { label, params, outcome: "ok", tps: measured.tps, prefillTps: measured.prefillTps, ttftMs: measured.ttftMs, vramMb, vramAbsMb: vramAfter };
   }
   /** Poll the manager state until the engine is running, the readiness window
    *  elapses (timeout), the process exits (crash), or an OOM line appears in the
@@ -5112,7 +5193,11 @@ var BenchRunner = class {
         max_tokens: maxTokens,
         temperature: 0,
         seed: 42,
-        stream: false
+        stream: false,
+        // Re-process the prompt instead of reusing the warmup's cached prefill — otherwise the
+        // engine only evaluates the few new template tokens and `prompt_per_second` reflects ~4
+        // tokens, not the real prefill throughput over the whole bench prompt.
+        cache_prompt: false
       }),
       signal: signals.length > 1 ? AbortSignal.any(signals) : signals[0]
     });
@@ -5120,7 +5205,11 @@ var BenchRunner = class {
     const data = await res.json();
     const t = data.timings;
     if (!t || typeof t.predicted_per_second !== "number") return null;
-    return { tps: t.predicted_per_second, ttftMs: typeof t.prompt_ms === "number" ? t.prompt_ms : 0 };
+    return {
+      tps: t.predicted_per_second,
+      prefillTps: typeof t.prompt_per_second === "number" ? t.prompt_per_second : null,
+      ttftMs: typeof t.prompt_ms === "number" ? t.prompt_ms : 0
+    };
   }
   // ---- card-derived recommended sampling (ADR-099) ------------------------
   /** Resolve the model's HF card and extract recommended sampling (temp/top_k/top_p/min_p).
@@ -5282,12 +5371,47 @@ function makeBenchContent(targetTokens) {
   return BENCH_BASE.repeat(reps).slice(0, targetChars) + "\n\nSummarize the passage above in one sentence.";
 }
 function benchPromptTokens(ctx) {
-  return Math.max(256, Math.min(5e4, Math.floor(ctx * 0.75)));
+  return Math.max(256, Math.min(8192, Math.floor(ctx * 0.75)));
+}
+function totalVramMb(sys) {
+  return sys.gpus.reduce((s, g) => s + (g.vramMb || 0), 0);
 }
-function overVram(vramMb, sys) {
-  const total = sys.gpus[0]?.vramMb ?? 0;
-  if (!vramMb || total <= 0) return false;
-  return vramMb > total * 0.95;
+function overHeadroom(vramAbsMb, sys) {
+  const total = totalVramMb(sys);
+  if (!vramAbsMb || total <= 0) return false;
+  return vramAbsMb > total - VRAM_HEADROOM_MB;
+}
+function pickKvQuants(baseKv, kvTypes) {
+  const supported = (t) => kvTypes.length === 0 ? t === baseKv : kvTypes.includes(t);
+  const out = [];
+  for (const t of [baseKv, ...QUALITY_KV]) if (supported(t) && !out.includes(t)) out.push(t);
+  return out;
+}
+function betterBySpeed(a, b) {
+  const at = a.tps ?? 0;
+  const bt = b.tps ?? 0;
+  if (bt <= 0) return at > 0;
+  const rel = (at - bt) / bt;
+  if (rel > OUTPUT_TIE) return true;
+  if (rel < -OUTPUT_TIE) return false;
+  return (a.prefillTps ?? 0) > (b.prefillTps ?? 0);
+}
+function kvBytes(t) {
+  return KV_BYTES[t] ?? 2;
+}
+function kvLargest(c) {
+  return c.reduce((a, b) => kvBytes(b) > kvBytes(a) ? b : a, c[0]);
+}
+function kvSmallest(c) {
+  return c.reduce((a, b) => kvBytes(b) < kvBytes(a) ? b : a, c[0]);
+}
+function decideKvToBench(spreadMb, candidates) {
+  const has = (t) => candidates.includes(t);
+  const largest = kvLargest(candidates);
+  if (spreadMb >= 0 && spreadMb <= KV_SPREAD_MIN) return [largest];
+  const smallest = has("turbo4") ? "turbo4" : kvSmallest(candidates);
+  const stock = has("q8_0") ? "q8_0" : largest;
+  return [.../* @__PURE__ */ new Set([smallest, stock])];
 }
 function readNvidiaVramMb() {
   return new Promise((resolve2) => {
@@ -5384,6 +5508,27 @@ var ModelRouter = class {
       unlock();
     }
   }
+  /** Every model key currently loaded (or loading) across the WHOLE pool — the primary
+   *  manager plus every alive extra slot (F-033). "Alive" = running OR starting, matching
+   *  the delete-guard's notion of "loaded" (routes.ts), so a model loaded via gateway
+   *  auto-swap into an extra slot is reported as loaded even though it isn't in the
+   *  primary manager. Used by overlayModel to mark gateway-loaded models loaded on the
+   *  Models page (they were previously invisible — only the primary manager was consulted). */
+  loadedModelKeys() {
+    const isAlive = (s) => s === "running" || s === "starting";
+    const keys = /* @__PURE__ */ new Set();
+    const add = (key) => {
+      keys.add(key);
+      const path = this.scanner.get(key)?.path;
+      if (path) keys.add(path);
+    };
+    const ms = this.manager.status();
+    if (isAlive(ms.state) && ms.model) add(ms.model.key);
+    for (const slot of this.extraSlots.values()) {
+      if (isAlive(slot.manager.status().state)) add(slot.modelKey);
+    }
+    return keys;
+  }
   // ── internal ──────────────────────────────────────────────────────────────
   async doLoad(entry) {
     {
@@ -6341,7 +6486,58 @@ import { spawn as spawn3 } from "child_process";
 var SUPPORTED = {
   claude: { bin: "claude", label: "Claude Code", install: "npm install -g @anthropic-ai/claude-code" }
 };
-async function launchCli(target, port2, passthrough, _spawn = spawn3) {
+async function fetchStatus(base2, _fetch = fetch) {
+  try {
+    const res = await _fetch(`${base2}/api/v1/status`, { signal: AbortSignal.timeout(3e3) });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchModels(base2, _fetch = fetch) {
+  try {
+    const res = await _fetch(`${base2}/api/v1/models`, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.models ?? [];
+  } catch {
+    return [];
+  }
+}
+function resolveModelKey(models, input) {
+  const byKey = models.find((m) => m.key === input);
+  if (byKey) return byKey.key;
+  const byName = models.find((m) => m.name === input);
+  if (byName) return byName.key;
+  const lower = input.toLowerCase();
+  const partial = models.find((m) => m.name.toLowerCase().includes(lower));
+  if (partial) return partial.key;
+  return null;
+}
+async function loadAndWait(base2, modelKey, timeoutMs = 18e4, _fetch = fetch) {
+  const loadRes = await _fetch(`${base2}/api/v1/engine/start`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ modelKey }),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!loadRes.ok) return false;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 1e3));
+    try {
+      const res = await _fetch(`${base2}/api/v1/status`, { signal: AbortSignal.timeout(3e3) });
+      if (!res.ok) continue;
+      const st = await res.json();
+      if (st.engine?.state === "running" && st.model?.key === modelKey) return true;
+      if (st.engine?.state === "error") return false;
+    } catch {
+    }
+  }
+  return false;
+}
+async function launchCli(target, port2, passthrough, _spawn = spawn3, modelKey, _fetch = fetch) {
   const spec = SUPPORTED[target];
   if (!target || !spec) {
     const list = Object.keys(SUPPORTED).join(", ");
@@ -6352,7 +6548,7 @@ async function launchCli(target, port2, passthrough, _spawn = spawn3) {
   const base2 = `http://127.0.0.1:${port2}`;
   let status;
   try {
-    const res = await fetch(`${base2}/api/v1/status`, { signal: AbortSignal.timeout(3e3) });
+    const res = await _fetch(`${base2}/api/v1/status`, { signal: AbortSignal.timeout(3e3) });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     status = await res.json();
   } catch {
@@ -6363,7 +6559,62 @@ Start the daemon first \u2014 run \`turbollm\` in another terminal \u2014 or pas
     );
     return 1;
   }
-  if (status.engine?.state !== "running" || !status.model?.name) {
+  const alreadyRunning = status?.engine?.state === "running" && !!status?.model?.name;
+  if (modelKey) {
+    const models = await fetchModels(base2, _fetch);
+    const resolvedKey = resolveModelKey(models, modelKey);
+    if (!resolvedKey) {
+      const list = models.map((m) => `  ${m.key}  (${m.name})`).join("\n");
+      process.stderr.write(
+        `Model not found: "${modelKey}"
+` + (list ? `Available models:
+${list}
+` : `No models in library \u2014 add one via the TurboLLM UI.
+`)
+      );
+      return 1;
+    }
+    if (alreadyRunning && status?.model?.key === resolvedKey) {
+    } else {
+      process.stdout.write(`\u25B8 Loading model "${resolvedKey}"\u2026
+`);
+      const loaded = await loadAndWait(base2, resolvedKey, 18e4, _fetch);
+      if (!loaded) {
+        process.stderr.write(
+          `Model did not finish loading within 180 s. Check the TurboLLM UI for errors, or try again.
+`
+        );
+        return 1;
+      }
+      const refreshed = await fetchStatus(base2, _fetch);
+      if (refreshed) status = refreshed;
+    }
+  } else if (!alreadyRunning) {
+    const models = await fetchModels(base2, _fetch);
+    if (models.length === 0) {
+      process.stderr.write(
+        `TurboLLM is running, but no model is loaded and no models are in the library.
+Open ${base2} \u2192 Models \u2192 add a model, then run this again.
+`
+      );
+      return 1;
+    }
+    const lastKey = status?.lastLoaded?.modelKey;
+    const autoKey = lastKey && models.some((m) => m.key === lastKey) ? lastKey : models[0].key;
+    process.stdout.write(`\u25B8 Auto-loading model "${autoKey}"\u2026
+`);
+    const loaded = await loadAndWait(base2, autoKey, 18e4, _fetch);
+    if (!loaded) {
+      process.stderr.write(
+        `Model did not finish loading within 180 s. Check the TurboLLM UI for errors, then run this again.
+`
+      );
+      return 1;
+    }
+    const refreshed = await fetchStatus(base2, _fetch);
+    if (refreshed) status = refreshed;
+  }
+  if (status?.engine?.state !== "running" || !status?.model?.name) {
     process.stderr.write(
       `TurboLLM is running, but no model is loaded.
 Open ${base2} \u2192 Models \u2192 Load a model, then run this again.
@@ -6410,18 +6661,120 @@ Install it:  ${spec.install}
   });
 }
 
+// src/daemon-pid.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, unlinkSync, existsSync as existsSync14 } from "fs";
+import { join as join16 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+function writePidfile(dir, pid, port2) {
+  const path = join16(dir, "daemon.pid");
+  writeFileSync7(path, JSON.stringify({ pid, port: port2 }));
+}
+function readPidfile(dir) {
+  const path = join16(dir, "daemon.pid");
+  if (!existsSync14(path)) return null;
+  try {
+    const raw = readFileSync7(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && typeof parsed.pid === "number" && typeof parsed.port === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function removePidfile(dir) {
+  try {
+    unlinkSync(join16(dir, "daemon.pid"));
+  } catch {
+  }
+}
+var defaultHooks = {
+  processExists(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  kill(pid, signal) {
+    process.kill(pid, signal);
+  },
+  taskkill(pid) {
+    execFileSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+  },
+  async confirmTurbollm(port2) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port2}/api/v1/status`, { signal: AbortSignal.timeout(2e3) });
+      if (!res.ok) return false;
+      const body3 = await res.json();
+      return typeof body3 === "object" && body3 !== null && "version" in body3 && "engine" in body3;
+    } catch {
+      return false;
+    }
+  },
+  platform: process.platform
+};
+async function waitForExit(pid, timeoutMs, hooks) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!hooks.processExists(pid)) return true;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return !hooks.processExists(pid);
+}
+async function stopDaemon(dir, hooks = defaultHooks) {
+  const data = readPidfile(dir);
+  if (!data) {
+    return { stopped: false, message: "No running TurboLLM daemon found." };
+  }
+  const { pid, port: port2 } = data;
+  if (!hooks.processExists(pid)) {
+    removePidfile(dir);
+    return { stopped: false, message: "No running TurboLLM daemon found." };
+  }
+  if (!await hooks.confirmTurbollm(port2)) {
+    const manual = hooks.platform === "win32" ? `taskkill /PID ${pid} /T /F` : `kill -9 ${pid}`;
+    return {
+      stopped: false,
+      message: `Found a pidfile (pid ${pid}, port ${port2}), but no TurboLLM daemon is responding there \u2014 it may be stale or the PID was reused by another process. Not killing it automatically.
+If you're sure it's TurboLLM, stop it manually: ${manual}`
+    };
+  }
+  try {
+    if (hooks.platform === "win32") {
+      hooks.taskkill(pid);
+      await waitForExit(pid, 2e3, hooks);
+    } else {
+      hooks.kill(pid, "SIGTERM");
+      const exited = await waitForExit(pid, 1e4, hooks);
+      if (!exited) {
+        try {
+          hooks.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+  } catch (e) {
+    return { stopped: false, message: `Failed to stop daemon (pid ${pid}): ${e instanceof Error ? e.message : e}` };
+  }
+  removePidfile(dir);
+  return { stopped: true, port: port2, message: `TurboLLM daemon stopped (port ${port2})` };
+}
+
 // src/server.ts
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { existsSync as existsSync18, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname8, join as join20, normalize as normalize2 } from "path";
+import { dirname as dirname8, join as join21, normalize as normalize2 } from "path";
 import { Agent, setGlobalDispatcher } from "undici";
 
 // src/api/routes.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync8, readdirSync as readdirSync7, realpathSync, rmSync as rmSync10, statSync as statSync5, writeFileSync as writeFileSync8 } from "fs";
-import { basename as basename3, dirname as dirname7, join as join19, resolve, sep } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync9, readdirSync as readdirSync7, realpathSync, rmSync as rmSync10, statSync as statSync5, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename3, dirname as dirname7, join as join20, resolve, sep } from "path";
 
 // src/comfyui/gate-template.ts
 var GATE_VERSION = 2;
@@ -7056,42 +7409,89 @@ ${content}` : b.docContext : content;
     return c.json({ url, onlyLocal });
   });
   app2.post("/api/v1/conversations/import", async (c) => {
-    let payload;
+    let raw;
     try {
-      payload = await c.req.json();
+      raw = await c.req.json();
     } catch {
       return err(c, 400, "invalid_file", "Body must be valid JSON.");
     }
-    if (!payload.format || payload.format !== "debug" && payload.format !== "export") {
-      return err(c, 400, "invalid_file", 'Missing or invalid "format" field. Expected a .turbollm-chat.json file.');
-    }
-    if (!payload.messages || !Array.isArray(payload.messages)) {
-      return err(c, 400, "invalid_file", 'Missing "messages" array.');
-    }
-    if (typeof payload.chat_id !== "string") {
-      return err(c, 400, "invalid_file", 'Missing "chat_id" field.');
-    }
-    if (typeof payload.title !== "string") {
-      return err(c, 400, "invalid_file", 'Missing "title" field.');
-    }
-    const title = payload.title || "Imported chat";
-    const modelKey = typeof payload.model === "string" ? payload.model : "";
-    const personaId = typeof payload.persona === "string" ? payload.persona : "default";
-    const toolPolicy = personaId === "research" ? "force_web_search" : void 0;
-    const newConv = db2.createConversation({ title, modelKey, toolPolicy });
-    const messages = payload.messages;
-    for (const m of messages) {
-      const role = m.role;
-      if (role !== "user" && role !== "assistant") continue;
-      const content = typeof m.content === "string" ? m.content : "";
-      const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : void 0;
-      db2.addMessage(newConv.id, role, content, {
-        toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : void 0
-      });
+    if (Array.isArray(raw)) {
+      return importOpenAiMessages(c, db2, raw, void 0, void 0);
+    }
+    if (typeof raw !== "object" || raw === null) {
+      return err(c, 400, "invalid_file", "Body must be a JSON array or object.");
+    }
+    const payload = raw;
+    if (payload.format === "debug" || payload.format === "export") {
+      if (!Array.isArray(payload.messages)) {
+        return err(c, 400, "invalid_file", 'Missing "messages" array.');
+      }
+      if (typeof payload.chat_id !== "string") {
+        return err(c, 400, "invalid_file", 'Missing "chat_id" field.');
+      }
+      if (typeof payload.title !== "string") {
+        return err(c, 400, "invalid_file", 'Missing "title" field.');
+      }
+      const title = payload.title || "Imported chat";
+      const modelKey = typeof payload.model === "string" ? payload.model : "";
+      const personaId = typeof payload.persona === "string" ? payload.persona : "default";
+      const toolPolicy = personaId === "research" ? "force_web_search" : void 0;
+      const newConv = db2.createConversation({ title, modelKey, toolPolicy });
+      const messages = payload.messages;
+      for (const m of messages) {
+        const role = m.role;
+        if (role !== "user" && role !== "assistant") continue;
+        const content = typeof m.content === "string" ? m.content : "";
+        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : void 0;
+        db2.addMessage(newConv.id, role, content, {
+          toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : void 0
+        });
+      }
+      return c.json({ id: newConv.id }, 201);
+    }
+    if (Array.isArray(payload.messages)) {
+      const titleField = typeof payload.title === "string" ? payload.title : void 0;
+      const modelField = typeof payload.model === "string" ? payload.model : void 0;
+      return importOpenAiMessages(c, db2, payload.messages, titleField, modelField);
     }
-    return c.json({ id: newConv.id }, 201);
+    return err(c, 400, "invalid_file", 'Unrecognised format. Expected a .turbollm-chat.json file or an OpenAI-format JSON (array or object with "messages" array).');
   });
 }
+function coerceContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => typeof p === "object" && p !== null).map((p) => typeof p.text === "string" ? p.text : "").filter(Boolean).join("\n");
+  }
+  return String(content ?? "");
+}
+function deriveTitle(titleField, messages) {
+  if (titleField?.trim()) return titleField.trim().slice(0, 60);
+  for (const m of messages) {
+    const role = m.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const text = coerceContent(m.content).trim();
+    if (text) {
+      const truncated = text.replace(/\s+/g, " ").slice(0, 60);
+      return truncated;
+    }
+  }
+  return "Imported chat";
+}
+function importOpenAiMessages(c, db2, messages, titleField, modelField) {
+  const usable = messages.filter((m) => m.role === "user" || m.role === "assistant");
+  if (usable.length === 0) {
+    return err(c, 400, "invalid_file", "No usable messages found (must have at least one user or assistant message).");
+  }
+  const title = deriveTitle(titleField, messages);
+  const modelKey = modelField ?? "";
+  const newConv = db2.createConversation({ title, modelKey });
+  for (const m of usable) {
+    const role = m.role;
+    const content = coerceContent(m.content);
+    db2.addMessage(newConv.id, role, content);
+  }
+  return c.json({ id: newConv.id }, 201);
+}
 function getLanIpForShare() {
   const nets = networkInterfaces();
   for (const ifaces of Object.values(nets)) {
@@ -7478,6 +7878,8 @@ async function runGeneration(d, stream, ctx) {
     ttftMs,
     totalMs,
     thinkMs,
+    // Full context occupancy: cache-reused prompt tokens still sit in the KV cache / context
+    // window (they're skipped only for recomputation), so they must stay counted here.
     ctxUsed: (finalUsage.prompt_tokens ?? 0) + (finalUsage.completion_tokens ?? 0),
     ctxMax,
     model: ms.model?.name ?? "",
@@ -7583,13 +7985,13 @@ async function autoTitle(d, convId, prevMessages, assistantReply, target) {
 
 // src/engines/scan.ts
 import { dirname as dirname5 } from "path";
-import { existsSync as existsSync14, statSync as statSync4 } from "fs";
+import { existsSync as existsSync15, statSync as statSync4 } from "fs";
 var serverBinName = process.platform === "win32" ? "llama-server.exe" : "llama-server";
 function skipScanDir(name) {
   return name === "node_modules" || name === ".git" || name.startsWith(".");
 }
 function resolveServerBinary(path, binName = serverBinName) {
-  if (!existsSync14(path)) return null;
+  if (!existsSync15(path)) return null;
   let isDir;
   try {
     isDir = statSync4(path).isDirectory();
@@ -7960,7 +8362,7 @@ function catalogEngine(id) {
 
 // src/engines/build-prereqs.ts
 import { execFile as execFile7 } from "child_process";
-import { delimiter, join as join16 } from "path";
+import { delimiter, join as join17 } from "path";
 import { promisify as promisify4 } from "util";
 var execFileP4 = promisify4(execFile7);
 function buildEnv(toolchainDirs = []) {
@@ -8037,7 +8439,7 @@ async function checkMsvc(env) {
   let version2;
   try {
     const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
-    const vswhere = join16(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
+    const vswhere = join17(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
     const out = await runVersion(vswhere, [
       "-latest",
       "-products",
@@ -8071,8 +8473,8 @@ async function checkBuildPrereqs(toolchainDirs = []) {
 
 // src/engines/build-runner.ts
 import { execFile as execFile8, spawn as spawn4 } from "child_process";
-import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync7, readdirSync as readdirSync5, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
-import { delimiter as delimiter2, dirname as dirname6, join as join17 } from "path";
+import { copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync8, readdirSync as readdirSync5, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
+import { delimiter as delimiter2, dirname as dirname6, join as join18 } from "path";
 import { promisify as promisify5 } from "util";
 var execFileP5 = promisify5(execFile8);
 function buildDirName(repoUrl, branch) {
@@ -8088,13 +8490,13 @@ function sameRepo(a, b) {
   return na !== "" && na === norm(b);
 }
 function sourceBuildBinary(enginesRoot, repoUrl, branch) {
-  const root = join17(enginesRoot, "build", buildDirName(repoUrl, branch));
-  return resolveServerBinary(join17(root, "build")) ?? resolveServerBinary(root);
+  const root = join18(enginesRoot, "build", buildDirName(repoUrl, branch));
+  return resolveServerBinary(join18(root, "build")) ?? resolveServerBinary(root);
 }
 function sourceBuildDirOf(binPath, enginesRoot) {
   const m = binPath.replace(/\\/g, "/").match(/\/engines\/build\/([^/]+)(?:\/|$)/i);
   if (!m) return null;
-  return join17(enginesRoot, "build", m[1]);
+  return join18(enginesRoot, "build", m[1]);
 }
 function pickGenerator(hasNinja) {
   return hasNinja ? "Ninja" : "NMake Makefiles";
@@ -8115,7 +8517,7 @@ function onPath(env, exe) {
   const key = Object.keys(env).find((k) => k.toLowerCase() === "path") ?? "PATH";
   return (env[key] ?? "").split(delimiter2).filter(Boolean).some((dir) => {
     try {
-      return existsSync15(join17(dir, exe));
+      return existsSync16(join18(dir, exe));
     } catch {
       return false;
     }
@@ -8127,15 +8529,15 @@ function cudaDllSourceDirs(env) {
   const pathDirs = (env[key] ?? "").split(delimiter2).filter(Boolean);
   const nvccDir = pathDirs.find((dir) => {
     try {
-      return existsSync15(join17(dir, "nvcc.exe"));
+      return existsSync16(join18(dir, "nvcc.exe"));
     } catch {
       return false;
     }
   });
   if (!nvccDir) return [];
-  return [nvccDir, join17(nvccDir, "x64")].filter((d) => {
+  return [nvccDir, join18(nvccDir, "x64")].filter((d) => {
     try {
-      return existsSync15(d);
+      return existsSync16(d);
     } catch {
       return false;
     }
@@ -8162,7 +8564,7 @@ function copyCudaRuntimeDlls(env, destDir, log) {
       if (seen.has(lower)) continue;
       if (!CUDA_RUNTIME_DLL_PREFIXES.some((p) => lower.startsWith(p))) continue;
       try {
-        copyFileSync(join17(dir, name), join17(destDir, name));
+        copyFileSync(join18(dir, name), join18(destDir, name));
         seen.add(lower);
         copied++;
       } catch {
@@ -8175,14 +8577,14 @@ function copyCudaRuntimeDlls(env, destDir, log) {
 async function findVcvarsall() {
   try {
     const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
-    const vswhere = join17(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
+    const vswhere = join18(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
     const { stdout } = await execFileP5(
       vswhere,
       ["-latest", "-products", "*", "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64", "-find", "VC\\Auxiliary\\Build\\vcvarsall.bat"],
       { timeout: 8e3, windowsHide: true, maxBuffer: 1024 * 1024 }
     );
     const p = stdout.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
-    return p && existsSync15(p) ? p : null;
+    return p && existsSync16(p) ? p : null;
   } catch {
     return null;
   }
@@ -8236,7 +8638,7 @@ function hasAssemblySources(dir) {
     }
     for (const e of entries) {
       if (e.isDirectory()) {
-        if (!SKIP.has(e.name.toLowerCase()) && !e.name.startsWith(".")) stack.push(join17(d, e.name));
+        if (!SKIP.has(e.name.toLowerCase()) && !e.name.startsWith(".")) stack.push(join18(d, e.name));
       } else if (/\.(s|asm)$/i.test(e.name)) {
         return true;
       }
@@ -8264,20 +8666,20 @@ function stripGenericAsmLanguage(text) {
 }
 function neutralizeGratuitousAsm(srcDir, log) {
   if (hasAssemblySources(srcDir)) return;
-  const candidates = [join17(srcDir, "CMakeLists.txt"), join17(srcDir, "ggml", "CMakeLists.txt")];
+  const candidates = [join18(srcDir, "CMakeLists.txt"), join18(srcDir, "ggml", "CMakeLists.txt")];
   let patched = 0;
   for (const file of candidates) {
-    if (!existsSync15(file)) continue;
+    if (!existsSync16(file)) continue;
     let text;
     try {
-      text = readFileSync7(file, "utf8");
+      text = readFileSync8(file, "utf8");
     } catch {
       continue;
     }
     const { text: next, changed } = stripGenericAsmLanguage(text);
     if (changed) {
       try {
-        writeFileSync7(file, next);
+        writeFileSync8(file, next);
         patched++;
       } catch {
       }
@@ -8307,9 +8709,9 @@ async function runBuild(req, hooks, signal) {
       'Could not locate the Visual Studio C++ build environment (vcvarsall.bat). Install the "Desktop development with C++" workload from the Visual Studio Build Tools.'
     );
   }
-  const buildRoot = join17(req.enginesRoot, "build", buildDirName(req.repoUrl, req.branch));
-  const srcDir = join17(buildRoot, "src");
-  const buildSubdir = join17(buildRoot, "build");
+  const buildRoot = join18(req.enginesRoot, "build", buildDirName(req.repoUrl, req.branch));
+  const srcDir = join18(buildRoot, "src");
+  const buildSubdir = join18(buildRoot, "build");
   rmSync8(buildRoot, { recursive: true, force: true });
   mkdirSync10(buildRoot, { recursive: true });
   hooks.phase("cloning");
@@ -8325,12 +8727,12 @@ async function runBuild(req, hooks, signal) {
     generator === "Ninja" ? "Using the Ninja generator (drives nvcc directly \u2014 no Visual Studio CUDA integration needed)." : "Ninja not found on PATH \u2014 using the NMake generator (works, but single-threaded and slower; add a folder containing ninja.exe under Build environment for much faster builds)."
   );
   hooks.phase("configuring");
-  const configureBat = join17(buildRoot, "_tllm_configure.bat");
-  writeFileSync7(configureBat, vcvarsBatch(vcvars, ["-G", generator, "-B", buildSubdir, "-S", srcDir, ...CMAKE_CONFIGURE_ARGS]));
+  const configureBat = join18(buildRoot, "_tllm_configure.bat");
+  writeFileSync8(configureBat, vcvarsBatch(vcvars, ["-G", generator, "-B", buildSubdir, "-S", srcDir, ...CMAKE_CONFIGURE_ARGS]));
   await runStep("cmd.exe", ["/c", configureBat], { cwd: buildRoot, env, signal, onLine: hooks.log });
   hooks.phase("compiling");
-  const compileBat = join17(buildRoot, "_tllm_build.bat");
-  writeFileSync7(compileBat, vcvarsBatch(vcvars, ["--build", buildSubdir, "-j", "--target", "llama-server"]));
+  const compileBat = join18(buildRoot, "_tllm_build.bat");
+  writeFileSync8(compileBat, vcvarsBatch(vcvars, ["--build", buildSubdir, "-j", "--target", "llama-server"]));
   await runStep("cmd.exe", ["/c", compileBat], { cwd: buildRoot, env, signal, onLine: hooks.log });
   hooks.phase("registering");
   const binPath = resolveServerBinary(buildSubdir) ?? resolveServerBinary(buildRoot);
@@ -8343,9 +8745,9 @@ async function runBuild(req, hooks, signal) {
 
 // src/engines/cuda-provision.ts
 import { execFile as execFile9 } from "child_process";
-import { cpSync as cpSync2, existsSync as existsSync16, mkdirSync as mkdirSync11, readdirSync as readdirSync6, rmSync as rmSync9 } from "fs";
+import { cpSync as cpSync2, existsSync as existsSync17, mkdirSync as mkdirSync11, readdirSync as readdirSync6, rmSync as rmSync9 } from "fs";
 import { tmpdir } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { promisify as promisify6 } from "util";
 var execFileP6 = promisify6(execFile9);
 var REDIST_BASE = "https://developer.download.nvidia.com/compute/cuda/redist/";
@@ -8400,9 +8802,9 @@ async function provisionCuda(dataDir, onProgress, signal) {
     phase: "resolving",
     message: `Using CUDA ${version2}${driverMax ? ` (driver supports up to ${driverMax})` : ""}.`
   });
-  const root = join18(dataDir, "cuda", version2);
-  const binDir = join18(root, "bin");
-  if (existsSync16(join18(binDir, "nvcc.exe"))) {
+  const root = join19(dataDir, "cuda", version2);
+  const binDir = join19(root, "bin");
+  if (existsSync17(join19(binDir, "nvcc.exe"))) {
     onProgress({ phase: "assembling", message: `CUDA ${version2} already downloaded \u2014 reusing it.` });
     return { root, binDir, version: version2 };
   }
@@ -8417,7 +8819,7 @@ async function provisionCuda(dataDir, onProgress, signal) {
     const rel = relOf(id);
     if (rel) components.push({ id, url: REDIST_BASE + rel });
   }
-  const work = join18(tmpdir(), `tllm-cuda-${version2}`);
+  const work = join19(tmpdir(), `tllm-cuda-${version2}`);
   rmSync9(work, { recursive: true, force: true });
   mkdirSync11(work, { recursive: true });
   const stageRoot = `${root}.partial`;
@@ -8426,23 +8828,23 @@ async function provisionCuda(dataDir, onProgress, signal) {
   try {
     for (let i = 0; i < components.length; i++) {
       const { id, url } = components[i];
-      const zip = join18(work, `${id}.zip`);
+      const zip = join19(work, `${id}.zip`);
       onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: 0 });
       await downloadFile(url, zip, (p) => onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: p.pct }), signal);
-      const exDir = join18(work, id);
+      const exDir = join19(work, id);
       mkdirSync11(exDir, { recursive: true });
       onProgress({ phase: "extracting", message: `Extracting ${id}\u2026` });
       await extractArchive(zip, exDir);
-      const inner = readdirSync6(exDir).map((n) => join18(exDir, n)).find((p) => existsSync16(join18(p, "include")) || existsSync16(join18(p, "bin")) || existsSync16(join18(p, "lib")));
-      const srcRoot = inner ?? join18(exDir, readdirSync6(exDir)[0] ?? "");
+      const inner = readdirSync6(exDir).map((n) => join19(exDir, n)).find((p) => existsSync17(join19(p, "include")) || existsSync17(join19(p, "bin")) || existsSync17(join19(p, "lib")));
+      const srcRoot = inner ?? join19(exDir, readdirSync6(exDir)[0] ?? "");
       cpSync2(srcRoot, stageRoot, { recursive: true, force: true });
       rmSync9(zip, { force: true });
     }
-    if (!existsSync16(join18(stageRoot, "bin", "nvcc.exe"))) {
+    if (!existsSync17(join19(stageRoot, "bin", "nvcc.exe"))) {
       throw new Error("Assembled CUDA toolkit is missing bin/nvcc.exe \u2014 the component set may have changed.");
     }
     rmSync9(root, { recursive: true, force: true });
-    mkdirSync11(join18(dataDir, "cuda"), { recursive: true });
+    mkdirSync11(join19(dataDir, "cuda"), { recursive: true });
     cpSync2(stageRoot, root, { recursive: true, force: true });
     onProgress({ phase: "assembling", message: `CUDA ${version2} ready.` });
     return { root, binDir, version: version2 };
@@ -8552,6 +8954,9 @@ function registerApi(app2, d) {
       version: d.version,
       engine,
       model,
+      // Last model the user loaded (config-tracked) — lets `turbollm launch` auto-load the
+      // true last-used model instead of guessing the first library entry (F-034).
+      lastLoaded: d.store.snapshot().lastLoaded,
       engineStats,
       liveGeneration,
       // Auto-tune runner state (spec 09 §1): real progress while a sweep runs, then
@@ -8570,7 +8975,7 @@ function registerApi(app2, d) {
         let installedVersion = null;
         if (gatePath) {
           try {
-            const src = readFileSync8(join19(gatePath, "__init__.py"), "utf-8");
+            const src = readFileSync9(join20(gatePath, "__init__.py"), "utf-8");
             const m = src.match(/^GATE_VERSION\s*=\s*(\d+)/m);
             if (m) installedVersion = Number(m[1]);
           } catch {
@@ -8592,7 +8997,7 @@ function registerApi(app2, d) {
     const sys = getSysInfo();
     const vendor = primaryVendor(sys);
     const recommended = recommendBackendId(vendor, sys.gpus.length > 0);
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const active = d.registry.active();
     const regEngines = d.registry.list().engines;
     const backendOf = (p) => p.match(/llama\.cpp-[^/\\]+-(cuda|rocm|sycl|vulkan|metal|cpu)/i)?.[1]?.toLowerCase();
@@ -8613,8 +9018,8 @@ function registerApi(app2, d) {
         engineId: eng?.id ?? ""
       };
     });
-    const mlxVenvPy = join19(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
-    const mlxInstalledOnDisk = existsSync17(mlxVenvPy);
+    const mlxVenvPy = join20(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+    const mlxInstalledOnDisk = existsSync18(mlxVenvPy);
     const mlxEngine = regEngines.find((e) => e.kind === "mlx");
     const mlx = {
       supported: process.platform === "darwin",
@@ -8629,7 +9034,7 @@ function registerApi(app2, d) {
     const b = await body2(c);
     const def = availableBackends().find((x) => x.id === b.backend);
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const existing = installedBackendBuild(root, def.id);
     if (existing) {
       return c.json({ accepted: false, alreadyInstalled: true, build: existing.tag });
@@ -8673,7 +9078,7 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/backends/:id/update", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const oldBin = installedBackendBuild(root, def.id)?.bin ?? null;
     if (!oldBin) return err2(c, 409, "not_installed", "Backend is not installed \u2014 download it first.");
     {
@@ -8732,7 +9137,7 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/backends/:id/enable", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const build2 = installedBackendBuild(root, def.id);
     if (!build2) return err2(c, 409, "not_installed", "Backend is not installed on disk \u2014 download it first.");
     let eng = d.registry.list().engines.find((e) => e.binPath === build2.bin);
@@ -8743,7 +9148,7 @@ function registerApi(app2, d) {
   app2.delete("/api/v1/engines/backends/:id", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const backendDirRe = new RegExp(`[\\\\/]engines[\\\\/]llama\\.cpp-[^\\\\/]+-${def.id}[\\\\/]`);
     const engs = d.registry.list().engines.filter((e) => backendDirRe.test(e.binPath));
     const activeId = d.registry.active()?.id;
@@ -8765,7 +9170,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err2(c, 409, "engine_already_running", busy);
     }
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -8782,29 +9187,29 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/engines/catalog", (c) => {
     const regEngines = d.registry.list().engines;
-    const enginesRoot = join19(d.store.dir(), "engines");
+    const enginesRoot = join20(d.store.dir(), "engines");
     const items = catalogForPlatform().map((e) => {
       let installed;
       let enabled;
       if (e.provision === "pip") {
         const venvSubdir = e.id === "mlx" ? "mlx" : "vllm";
-        const pyPath = join19(
+        const pyPath = join20(
           enginesRoot,
           venvSubdir,
           "venv",
           process.platform === "win32" ? "Scripts/python.exe" : "bin/python"
         );
-        installed = existsSync17(pyPath);
+        installed = existsSync18(pyPath);
         enabled = regEngines.some((x) => x.kind === e.kind);
       } else if (e.id === "turboquant") {
-        const tqDir = join19(enginesRoot, "turboquant");
-        installed = existsSync17(tqDir);
+        const tqDir = join20(enginesRoot, "turboquant");
+        installed = existsSync18(tqDir);
         enabled = regEngines.some((x) => /[\\/]engines[\\/]turboquant[\\/]/.test(x.binPath));
       } else if (e.id === "koboldcpp") {
-        installed = existsSync17(koboldcppBinPath(enginesRoot));
+        installed = existsSync18(koboldcppBinPath(enginesRoot));
         enabled = regEngines.some((x) => x.kind === "koboldcpp");
       } else if (e.id === "llamafile") {
-        installed = existsSync17(llamafileBinPath(enginesRoot));
+        installed = existsSync18(llamafileBinPath(enginesRoot));
         enabled = regEngines.some((x) => x.kind === "llamafile");
       }
       const srcEng = regEngines.find((x) => sameRepo(x.sourceRepo, e.homepage));
@@ -8854,9 +9259,9 @@ function registerApi(app2, d) {
     const busy = engineWorkBusy(d);
     if (busy) return err2(c, 409, "engine_already_running", busy);
     const name = (b.name ?? "").trim() || void 0;
-    const enginesRoot = join19(d.store.dir(), "engines");
+    const enginesRoot = join20(d.store.dir(), "engines");
     const toolchainDirs = d.store.snapshot().build.toolchainDirs;
-    const buildRoot = join19(enginesRoot, "build", buildDirName(repoUrl, branch));
+    const buildRoot = join20(enginesRoot, "build", buildDirName(repoUrl, branch));
     const ac = new AbortController();
     buildAbort = ac;
     d.build.start(name ?? repoUrl);
@@ -8959,7 +9364,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err2(c, 409, "engine_already_running", busy);
     }
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -8984,14 +9389,14 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err2(c, 409, "engine_already_running", busy);
     }
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("turboquant");
         if (upgrade) {
-          const tqDir = join19(root, "turboquant");
-          if (existsSync17(tqDir)) rmSync10(tqDir, { recursive: true, force: true });
+          const tqDir = join20(root, "turboquant");
+          if (existsSync18(tqDir)) rmSync10(tqDir, { recursive: true, force: true });
         }
         const bin = await provisionTurboquant(
           root,
@@ -9019,7 +9424,7 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err2(c, 409, "engine_already_running", busy);
     }
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     const hasNvidia = primaryVendor(getSysInfo()) === "nvidia";
     void (async () => {
@@ -9027,7 +9432,7 @@ function registerApi(app2, d) {
         d.provision.start("koboldcpp");
         if (upgrade) {
           const dir = koboldcppDir(root);
-          if (existsSync17(dir)) rmSync10(dir, { recursive: true, force: true });
+          if (existsSync18(dir)) rmSync10(dir, { recursive: true, force: true });
         }
         const rt = await ensureKoboldcpp(root, hasNvidia, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addKoboldcpp(`KoboldCpp (${rt.version})`, rt.binPath, rt.version);
@@ -9050,14 +9455,14 @@ function registerApi(app2, d) {
       const busy = engineWorkBusy(d);
       if (busy) return err2(c, 409, "engine_already_running", busy);
     }
-    const root = join19(d.store.dir(), "engines");
+    const root = join20(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("llamafile");
         if (upgrade) {
           const dir = llamafileDir(root);
-          if (existsSync17(dir)) rmSync10(dir, { recursive: true, force: true });
+          if (existsSync18(dir)) rmSync10(dir, { recursive: true, force: true });
         }
         const rt = await ensureLlamafile(root, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addLlamafile(`llamafile (${rt.version})`, rt.binPath, rt.version);
@@ -9137,9 +9542,9 @@ function registerApi(app2, d) {
       const eng = d.registry.get(id);
       d.registry.remove(id);
       if (purge && eng) {
-        const enginesRoot = join19(d.store.dir(), "engines");
+        const enginesRoot = join20(d.store.dir(), "engines");
         const purgeDir = engineInstallDir(eng, enginesRoot);
-        if (purgeDir && existsSync17(purgeDir)) {
+        if (purgeDir && existsSync18(purgeDir)) {
           rmSync10(purgeDir, { recursive: true, force: true });
         }
       }
@@ -9224,12 +9629,12 @@ function registerApi(app2, d) {
         let isDir = d2.isDirectory();
         if (d2.isSymbolicLink()) {
           try {
-            isDir = statSync5(join19(real, d2.name)).isDirectory();
+            isDir = statSync5(join20(real, d2.name)).isDirectory();
           } catch {
             isDir = false;
           }
         }
-        return { name: d2.name, path: join19(real, d2.name), isDir };
+        return { name: d2.name, path: join20(real, d2.name), isDir };
       }).sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1);
     } catch {
       return err2(c, 400, "fs_read_failed", "Could not read that folder (permission denied or not a directory).");
@@ -9329,22 +9734,22 @@ function registerApi(app2, d) {
     const raw = (b.path ?? "").trim();
     if (!raw) return err2(c, 400, "invalid_config_value", "Enter the path to your ComfyUI folder.");
     const root = resolve(raw);
-    if (!existsSync17(root) || !statSync5(root).isDirectory()) {
+    if (!existsSync18(root) || !statSync5(root).isDirectory()) {
       return err2(c, 400, "invalid_config_value", "That folder does not exist.");
     }
     let customNodes;
     if (basename3(root).toLowerCase() === "custom_nodes") customNodes = root;
-    else if (existsSync17(join19(root, "custom_nodes"))) customNodes = join19(root, "custom_nodes");
+    else if (existsSync18(join20(root, "custom_nodes"))) customNodes = join20(root, "custom_nodes");
     else {
       return err2(c, 400, "invalid_config_value", "No 'custom_nodes' folder here. Point me at your ComfyUI folder or its custom_nodes folder.");
     }
     const reqUrl = new URL(c.req.url);
     const port2 = reqUrl.port || (reqUrl.protocol === "https:" ? "443" : "80");
     const base2 = `http://127.0.0.1:${port2}`;
-    const gateDir = join19(customNodes, "turbollm_gate");
+    const gateDir = join20(customNodes, "turbollm_gate");
     try {
       mkdirSync12(gateDir, { recursive: true });
-      writeFileSync8(join19(gateDir, "__init__.py"), gateNodeSource(base2));
+      writeFileSync9(join20(gateDir, "__init__.py"), gateNodeSource(base2));
     } catch (e) {
       return err2(c, 500, "fs_write_failed", `Could not write the gate node: ${e instanceof Error ? e.message : e}`);
     }
@@ -9355,7 +9760,7 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/comfyui/uninstall", (c) => {
     const dir = d.store.snapshot().comfyui.gatePath;
-    if (dir && existsSync17(dir)) {
+    if (dir && existsSync18(dir)) {
       try {
         rmSync10(dir, { recursive: true, force: true });
       } catch (e) {
@@ -9390,8 +9795,8 @@ function registerApi(app2, d) {
       });
       while (!aborted) {
         const path = d.manager.logPath();
-        if (path && existsSync17(path)) {
-          const lines = readFileSync8(path, "utf8").split("\n");
+        if (path && existsSync18(path)) {
+          const lines = readFileSync9(path, "utf8").split("\n");
           for (; sent < lines.length - 1; sent++) {
             await stream.writeSSE({ event: "line", data: JSON.stringify({ line: lines[sent].replace(/\r$/, "") }) });
           }
@@ -9687,7 +10092,7 @@ function registerApi(app2, d) {
     const b = await body2(c);
     const dir = (b.dir ?? "").trim();
     if (!dir || !/^([a-zA-Z]:[\\/]|[\\/])/.test(dir)) return err2(c, 400, "invalid_config_value", "Path must be absolute.");
-    if (!existsSync17(dir)) return err2(c, 400, "invalid_config_value", "That folder does not exist.");
+    if (!existsSync18(dir)) return err2(c, 400, "invalid_config_value", "That folder does not exist.");
     try {
       d.store.update((cfg2) => {
         if (!cfg2.modelDirs.includes(dir)) cfg2.modelDirs.push(dir);
@@ -9865,7 +10270,9 @@ function overlayModel(e, d, lastTpsMap) {
   const loadedKey = ms.state === "running" ? ms.model?.key : void 0;
   const snap = d.store.snapshot();
   const profiles = snap.modelProfiles;
-  const loaded = loadedKey === e.path || loadedKey === e.key;
+  const loadedInPrimary = loadedKey === e.path || loadedKey === e.key;
+  const poolKeys = d.modelRouter.loadedModelKeys();
+  const loaded = loadedInPrimary || poolKeys.has(e.key) || poolKeys.has(e.path);
   const lastTps = (lastTpsMap ?? d.db.lastGenTpsByModel()).get(e.key) ?? null;
   const liveTps = loaded && lastTps !== null ? lastTps : null;
   const benchTps = snap.benchResults[e.key]?.tps ?? null;
@@ -10017,15 +10424,15 @@ function engineInstallDir(eng, enginesRoot) {
     return n.startsWith(norm + "/") || n.startsWith(norm + "\\");
   };
   if (eng.kind === "mlx") {
-    const d = join19(enginesRoot, "mlx", "venv");
+    const d = join20(enginesRoot, "mlx", "venv");
     return inside(d) ? d : null;
   }
   if (eng.kind === "vllm") {
-    const d = join19(enginesRoot, "vllm", "venv");
+    const d = join20(enginesRoot, "vllm", "venv");
     return inside(d) ? d : null;
   }
   if (/[\\/]engines[\\/]turboquant[\\/]/.test(eng.binPath)) {
-    const d = join19(enginesRoot, "turboquant");
+    const d = join20(enginesRoot, "turboquant");
     return inside(d) ? d : null;
   }
   if (eng.kind === "koboldcpp") {
@@ -10040,7 +10447,7 @@ function engineInstallDir(eng, enginesRoot) {
   if (srcDir) return inside(srcDir) ? srcDir : null;
   const llamaMatch = eng.binPath.replace(/\\/g, "/").match(/\/(llama\.cpp-[^/]+)\//i);
   if (llamaMatch) {
-    const d = join19(enginesRoot, llamaMatch[1]);
+    const d = join20(enginesRoot, llamaMatch[1]);
     return inside(d) ? d : null;
   }
   return null;
@@ -10056,9 +10463,9 @@ function cleanModelName(p) {
   return basename3(p).replace(/\.gguf$/i, "");
 }
 function readTail2(path, n) {
-  if (!path || !existsSync17(path)) return [];
+  if (!path || !existsSync18(path)) return [];
   try {
-    const lines = readFileSync8(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
+    const lines = readFileSync9(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
     return lines.length > n ? lines.slice(-n) : lines;
   } catch {
     return [];
@@ -10375,7 +10782,8 @@ async function* streamToAnthropic(oaiStream, modelName, msgId, onUsage, onLive)
         if (usage?.completion_tokens) outputTokens = usage.completion_tokens;
         if (usage?.prompt_tokens) inputTokens = usage.prompt_tokens;
         const timings = chunk.timings;
-        if (timings?.prompt_n_reuse != null) cacheReadTokens = timings.prompt_n_reuse;
+        const cacheN = timings?.cache_n ?? timings?.prompt_n_reuse;
+        if (cacheN != null) cacheReadTokens = cacheN;
         const choices = chunk.choices;
         if (!choices?.length) continue;
         const choice = choices[0];
@@ -10749,7 +11157,7 @@ async function recordOpenAiStreamUsage(d, body3) {
 
 // src/server.ts
 setGlobalDispatcher(new Agent({ keepAliveMaxTimeout: 6e4, connections: 10 }));
-var WEB_ROOT = join20(dirname8(fileURLToPath(import.meta.url)), "webdist");
+var WEB_ROOT = join21(dirname8(fileURLToPath(import.meta.url)), "webdist");
 function createApp(d) {
   const app2 = new Hono();
   app2.use(
@@ -10774,12 +11182,12 @@ function createApp(d) {
     if (path.startsWith("api/") || path.startsWith("v1/")) {
       return c.json({ error: { code: "not_found", message: "Unknown endpoint." } }, 404);
     }
-    let file = normalize2(join20(WEB_ROOT, path || "index.html"));
-    if (!file.startsWith(WEB_ROOT) || !existsSync18(file) || statSync6(file).isDirectory()) {
-      file = join20(WEB_ROOT, "index.html");
+    let file = normalize2(join21(WEB_ROOT, path || "index.html"));
+    if (!file.startsWith(WEB_ROOT) || !existsSync19(file) || statSync6(file).isDirectory()) {
+      file = join21(WEB_ROOT, "index.html");
     }
-    if (!existsSync18(file)) return c.text("web ui not built \u2014 run `npm run build:web`", 500);
-    return new Response(readFileSync9(file), { status: 200, headers: { "Content-Type": contentType(file) } });
+    if (!existsSync19(file)) return c.text("web ui not built \u2014 run `npm run build:web`", 500);
+    return new Response(readFileSync10(file), { status: 200, headers: { "Content-Type": contentType(file) } });
   });
   return app2;
 }
@@ -10806,8 +11214,8 @@ function contentType(file) {
 // src/cli.ts
 var version = "0.1.1";
 try {
-  const pkgPath = join21(dirname9(fileURLToPath2(import.meta.url)), "..", "package.json");
-  version = JSON.parse(readFileSync10(pkgPath, "utf8")).version ?? version;
+  const pkgPath = join22(dirname9(fileURLToPath2(import.meta.url)), "..", "package.json");
+  version = JSON.parse(readFileSync11(pkgPath, "utf8")).version ?? version;
 } catch {
 }
 var nodeMajor = Number(process.versions.node.split(".")[0]);
@@ -10835,8 +11243,11 @@ function argValue(name, fallback) {
 if (argv[0] === "launch") {
   const target = argv[1] ?? "";
   const port2 = Number(argValue("--port", "")) || 6996;
-  const passthrough = argv.slice(2).filter((a, i, arr) => a !== "--port" && arr[i - 1] !== "--port");
-  const code = await launchCli(target, port2, passthrough);
+  const modelKey = argValue("--model", "") || void 0;
+  const passthrough = argv.slice(2).filter(
+    (a, i, arr) => a !== "--port" && arr[i - 1] !== "--port" && a !== "--model" && arr[i - 1] !== "--model"
+  );
+  const code = await launchCli(target, port2, passthrough, void 0, modelKey);
   process.exit(code);
 }
 if (hasFlag("--help", "-h")) {
@@ -10851,13 +11262,15 @@ Usage:
 
 Commands:
   launch claude                    Launch Claude Code wired to TurboLLM
-                                   (daemon must be running with a model loaded)
+                                   Auto-loads the last-used model if none is loaded.
+  launch claude --model <key>      Load a specific model by key or name, then launch
 
 Options:
   --port <n>     Port to listen on / connect to (default: 6996)
   --addr <h:p>   Full host:port override (e.g. 0.0.0.0:6996)
   --no-open      Do not open a browser window on startup
   --config <f>   Path to a custom config file
+  --stop         Stop a running TurboLLM daemon and exit
   --help, -h     Show this help message
 
 Examples:
@@ -10865,7 +11278,9 @@ Examples:
   turbollm --port 9000             # listen on port 9000
   turbollm --no-open               # start without opening a browser
   turbollm --addr 0.0.0.0:6996    # bind to all interfaces (LAN sharing)
+  turbollm --stop                  # stop the running daemon
   turbollm launch claude           # open Claude Code on your loaded model
+  turbollm launch claude --model qwen3-8b   # load qwen3-8b, then launch
 
 `
   );
@@ -10876,6 +11291,11 @@ var store = ConfigStore.load(argValue("--config", defaultConfigPath()));
 if (store.brokenBackup()) {
   console.warn(`config was reset; previous file backed up at ${store.brokenBackup()}`);
 }
+if (hasFlag("--stop")) {
+  const result = await stopDaemon(store.dir());
+  process.stdout.write(result.message + "\n");
+  process.exit(0);
+}
 var reaped = await reapStaleEngines(store.dir()).catch(() => 0);
 if (reaped > 0) console.log(`reaped ${reaped} orphaned engine process(es) from a previous run`);
 var registry = new Registry(store);
@@ -10884,7 +11304,7 @@ if (pruned > 0) console.log(`pruned ${pruned} dangling engine build(s)`);
 var provision = new ProvisionState();
 var build = new BuildState();
 var updates = new UpdateChecker();
-var enginesDir = join21(store.dir(), "engines");
+var enginesDir = join22(store.dir(), "engines");
 void seedDefaultEngines(registry, enginesDir, provision).then(() => registry.ensureProbed());
 var manager = new Manager(store);
 var scanner = new Scanner(store);
@@ -10980,6 +11400,10 @@ function listen(attempt = 0) {
     }
     process.stdout.write(`TurboLLM ${version} listening on http://${displayHost}:${info.port}
 `);
+    try {
+      writePidfile(store.dir(), process.pid, info.port);
+    } catch {
+    }
   });
   s.on?.(
     "error",
@@ -11031,7 +11455,7 @@ var restarting = false;
 function spawnReplacement() {
   let out = "ignore";
   try {
-    out = openSync3(join21(store.dir(), "restart.log"), "a");
+    out = openSync3(join22(store.dir(), "restart.log"), "a");
   } catch {
     out = "ignore";
   }
@@ -11127,6 +11551,10 @@ for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
     if (shuttingDown) return;
     shuttingDown = true;
     console.log("shutting down");
+    try {
+      removePidfile(store.dir());
+    } catch {
+    }
     updateScheduler.stop();
     comfy.stop();
     toolRegistry.disconnectAll();
@@ -11142,4 +11570,8 @@ process.on("exit", () => {
     killTrackedEnginesSync(store.dir());
   } catch {
   }
+  try {
+    removePidfile(store.dir());
+  } catch {
+  }
 });