metrillm-mcp 0.2.1 → 0.2.2

package/dist/index.js

@@ -28,10 +28,22 @@ import { Ollama } from "ollama";
 
 // ../src/utils.ts
 import vm from "vm";
-import { execFile } from "child_process";
+import { execFile, spawn } from "child_process";
 function openUrl(url) {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  execFile(cmd, [url]);
+  if (process.platform === "win32") {
+    const child2 = spawn("cmd", ["/c", "start", "", url], {
+      windowsHide: true,
+      stdio: "ignore"
+    });
+    child2.on("error", () => {
+    });
+    child2.unref();
+    return;
+  }
+  const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+  const child = execFile(cmd, [url]);
+  child.on("error", () => {
+  });
 }
 function avg(nums) {
   if (nums.length === 0) return 0;
@@ -515,7 +527,8 @@ function extractCodeBlock(text, preferredFunctionName) {
 var client = new Ollama();
 var DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
 var OLLAMA_INIT_TIMEOUT_MS = 12e4;
-var STREAM_STALL_TIMEOUT_MS = 3e4;
+var DEFAULT_STREAM_STALL_TIMEOUT_MS = 3e4;
+var SHARED_STREAM_STALL_TIMEOUT_ENV = "METRILLM_STREAM_STALL_TIMEOUT_MS";
 function getOllamaBaseUrl() {
   const configured = process.env.OLLAMA_HOST?.trim();
   if (!configured) return DEFAULT_OLLAMA_HOST;
@@ -575,6 +588,23 @@ function isUnsupportedSamplingOptionError(err) {
   if (!mentionsSampling) return false;
   return /unrecognized|unknown|not support|unsupported|invalid|unexpected|additional|extra/.test(lower);
 }
+function parseNonNegativeInt(value) {
+  if (!/^\d+$/.test(value)) return null;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) return null;
+  return parsed;
+}
+function resolveStreamStallTimeoutMs(override) {
+  if (override !== void 0) {
+    if (!Number.isFinite(override) || override < 0) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+    return override === 0 ? void 0 : Math.trunc(override);
+  }
+  const configured = process.env[SHARED_STREAM_STALL_TIMEOUT_ENV]?.trim();
+  if (!configured) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+  const parsed = parseNonNegativeInt(configured);
+  if (parsed === null) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+  return parsed === 0 ? void 0 : parsed;
+}
 function buildGenerateRequest(model, prompt, options, includeSampling) {
   return {
     model,
@@ -594,6 +624,8 @@ async function generate(model, prompt, options) {
   return generateStream(model, prompt, void 0, options);
 }
 async function generateStream(model, prompt, callbacks, options) {
+  const stallTimeoutMs = resolveStreamStallTimeoutMs(options?.stall_timeout_ms);
+  let abortedByStallTimeout = false;
   const initializeStream = (includeSampling) => withTimeout(
     client.generate(buildGenerateRequest(model, prompt, options, includeSampling)),
     OLLAMA_INIT_TIMEOUT_MS,
@@ -615,10 +647,12 @@ async function generateStream(model, prompt, callbacks, options) {
   let firstChunkSeen = false;
   let stallTimer = null;
   const resetStallTimer = () => {
+    if (stallTimeoutMs === void 0) return;
     if (stallTimer) clearTimeout(stallTimer);
     stallTimer = setTimeout(() => {
+      abortedByStallTimeout = true;
       client.abort();
-    }, STREAM_STALL_TIMEOUT_MS);
+    }, stallTimeoutMs);
   };
   try {
     resetStallTimer();
@@ -653,6 +687,9 @@ async function generateStream(model, prompt, callbacks, options) {
     if (stallTimer) clearTimeout(stallTimer);
   }
   if (!result) {
+    if (abortedByStallTimeout && stallTimeoutMs !== void 0) {
+      throw new Error(`Ollama stream timed out after ${stallTimeoutMs}ms`);
+    }
     throw new Error("Stream ended without done signal");
   }
   callbacks?.onDone?.(result);
@@ -682,14 +719,18 @@ function abortOngoingRequests() {
 import os from "os";
 import path from "path";
 import { promises as fs } from "fs";
+import { execFile as execFile2 } from "child_process";
 var DEFAULT_LM_STUDIO_BASE_URL = "http://127.0.0.1:1234";
 var LM_STUDIO_INIT_TIMEOUT_MS = 15e3;
 var LM_STUDIO_METADATA_TIMEOUT_MS = 2e3;
-var DEFAULT_STREAM_STALL_TIMEOUT_MS = 18e4;
+var DEFAULT_STREAM_STALL_TIMEOUT_MS2 = 3e4;
+var LM_STUDIO_CLI_TIMEOUT_MS = 8e3;
+var SHARED_STREAM_STALL_TIMEOUT_ENV2 = "METRILLM_STREAM_STALL_TIMEOUT_MS";
 var DEFAULT_LM_STUDIO_HOME_DIR = path.join(os.homedir(), ".lmstudio");
 var DEFAULT_LM_STUDIO_MODELS_DIR = path.join(DEFAULT_LM_STUDIO_HOME_DIR, "models");
 var LM_STUDIO_HOME_DIR_ENV = "LM_STUDIO_HOME_DIR";
 var LM_STUDIO_MODELS_DIR_ENV = "LM_STUDIO_MODELS_DIR";
+var LM_STUDIO_CLI_PATH_ENV = "LM_STUDIO_CLI_PATH";
 var defaultKeepAlive2;
 var activeAbortControllers = /* @__PURE__ */ new Set();
 var directorySizeCache = /* @__PURE__ */ new Map();
@@ -717,14 +758,9 @@ function assertThinkingModeRespected(model, think, response, reasoning) {
     );
   }
 }
-function buildThinkingConfig(think) {
-  if (think === void 0) return {};
-  const effort = think ? "high" : "low";
-  return {
-    include_reasoning: think,
-    reasoning_effort: effort,
-    reasoning: { effort }
-  };
+function buildNativeThinkingOption(think) {
+  if (think !== true) return void 0;
+  return "high";
 }
 function hasSamplingOverrides2(options) {
   return options?.top_p !== void 0 || options?.seed !== void 0;
@@ -768,38 +804,106 @@ function buildLMStudioRequestError(kind, model, status, statusText, body) {
   const suffix = backendMessage ? ` ${backendMessage}` : "";
   return new Error(`LM Studio ${kind} failed (${status} ${statusText})${suffix}`.trim());
 }
-function buildChatCompletionBody(model, prompt, options, stream, includeSampling) {
-  const messages = options?.think === false ? [
-    { role: "system", content: NON_THINKING_SYSTEM_PROMPT },
-    { role: "user", content: prompt }
-  ] : [{ role: "user", content: prompt }];
+function buildNativeChatBody(model, prompt, options, stream, includeSampling) {
+  const reasoning = buildNativeThinkingOption(options?.think);
   return {
     model,
-    messages,
+    input: prompt,
     temperature: options?.temperature ?? 0,
     ...includeSampling && options?.top_p !== void 0 ? { top_p: options.top_p } : {},
     ...includeSampling && options?.seed !== void 0 ? { seed: options.seed } : {},
     max_tokens: options?.num_predict ?? 512,
     stream,
-    ...stream ? { stream_options: { include_usage: true } } : {},
-    ...buildThinkingConfig(options?.think)
+    ...reasoning !== void 0 ? { reasoning } : {},
+    ...options?.think === false ? { system_prompt: NON_THINKING_SYSTEM_PROMPT } : {}
   };
 }
-function parseNonNegativeInt(value) {
+function getNativeStatNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return value;
+}
+function flattenNativeText(value, depth = 0) {
+  if (depth > 3 || value == null) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => flattenNativeText(item, depth + 1)).join("");
+  }
+  if (typeof value === "object") {
+    const candidate = value;
+    return flattenNativeText(candidate.text, depth + 1) || flattenNativeText(candidate.content, depth + 1) || flattenNativeText(candidate.delta, depth + 1) || flattenNativeText(candidate.value, depth + 1);
+  }
+  return "";
+}
+function collectNativeOutput(output4) {
+  if (!Array.isArray(output4)) {
+    return { response: "", reasoning: "" };
+  }
+  let response = "";
+  let reasoning = "";
+  for (const item of output4) {
+    if (typeof item !== "object" || item === null) continue;
+    const nativeItem = item;
+    const text = flattenNativeText(nativeItem.text ?? nativeItem.content).trim();
+    if (!text) continue;
+    const type = asNonEmptyString(nativeItem.type)?.toLowerCase() ?? "";
+    if (type.includes("reason")) {
+      reasoning += text;
+    } else {
+      response += text;
+    }
+  }
+  return { response, reasoning };
+}
+function extractNativeStats(payload) {
+  if (typeof payload !== "object" || payload === null) return void 0;
+  const direct = payload.stats;
+  if (direct) return direct;
+  const result = payload.result?.stats;
+  return result;
+}
+function extractNativeResponse(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return { response: "", reasoning: "" };
+  }
+  const resultOutput = payload.result?.output;
+  const directOutput = payload.output;
+  const fromResult = collectNativeOutput(resultOutput);
+  if (fromResult.response || fromResult.reasoning) return fromResult;
+  return collectNativeOutput(directOutput);
+}
+function extractNativeDelta(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return { response: "", reasoning: "" };
+  }
+  const type = asNonEmptyString(payload.type)?.toLowerCase() ?? "";
+  const directText = flattenNativeText(payload.delta);
+  const fallbackText = directText || flattenNativeText(payload.content) || flattenNativeText(payload.text);
+  if (!fallbackText) {
+    return { response: "", reasoning: "" };
+  }
+  if (type.includes("reason")) {
+    return { response: "", reasoning: fallbackText };
+  }
+  if (type.includes("message") || type.includes("text") || type.includes("content")) {
+    return { response: fallbackText, reasoning: "" };
+  }
+  return { response: fallbackText, reasoning: "" };
+}
+function parseNonNegativeInt2(value) {
   if (!/^\d+$/.test(value)) return null;
   const parsed = Number.parseInt(value, 10);
   if (!Number.isSafeInteger(parsed) || parsed < 0) return null;
   return parsed;
 }
-function resolveStreamStallTimeoutMs(override) {
+function resolveStreamStallTimeoutMs2(override) {
   if (override !== void 0) {
-    if (!Number.isFinite(override) || override < 0) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+    if (!Number.isFinite(override) || override < 0) return DEFAULT_STREAM_STALL_TIMEOUT_MS2;
     return override === 0 ? void 0 : Math.trunc(override);
   }
-  const configured = process.env.LM_STUDIO_STREAM_STALL_TIMEOUT_MS?.trim();
-  if (!configured) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
-  const parsed = parseNonNegativeInt(configured);
-  if (parsed === null) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+  const configured = process.env[SHARED_STREAM_STALL_TIMEOUT_ENV2]?.trim();
+  if (!configured) return DEFAULT_STREAM_STALL_TIMEOUT_MS2;
+  const parsed = parseNonNegativeInt2(configured);
+  if (parsed === null) return DEFAULT_STREAM_STALL_TIMEOUT_MS2;
   return parsed === 0 ? void 0 : parsed;
 }
 function getLMStudioBaseUrl() {
@@ -822,25 +926,29 @@ function getLMStudioHeaders() {
   }
   return headers;
 }
-function extractUsage(payload) {
-  if (typeof payload !== "object" || payload === null) return void 0;
-  const usage = payload.usage;
-  if (!usage) return void 0;
-  return usage;
-}
-function extractChoice2(payload) {
-  if (typeof payload !== "object" || payload === null) return void 0;
-  const choices = payload.choices;
-  if (!choices || choices.length === 0) return void 0;
-  return choices[0];
-}
-function extractContent(choice) {
-  const content = choice?.delta?.content ?? choice?.message?.content;
-  return typeof content === "string" ? content : "";
+function getUsageTokenCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  if (value <= 0) return 0;
+  return Math.trunc(value);
+}
+function estimateCompletionTokensFallback(text) {
+  const normalized = text.trim();
+  if (!normalized) return 0;
+  const cjkMatches = normalized.match(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/gu);
+  const cjkCount = cjkMatches?.length ?? 0;
+  const withoutCjk = normalized.replace(
+    /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/gu,
+    ""
+  );
+  const nonCjkChars = withoutCjk.replace(/\s+/g, "").length;
+  const nonCjkHeuristic = Math.ceil(nonCjkChars / 4);
+  const whitespaceEstimate = estimateTokenCount(normalized);
+  return Math.max(1, Math.max(whitespaceEstimate, cjkCount + nonCjkHeuristic));
 }
-function extractReasoning(choice) {
-  const reasoning = choice?.delta?.reasoning_content ?? choice?.delta?.reasoning ?? choice?.message?.reasoning_content ?? choice?.message?.reasoning;
-  return typeof reasoning === "string" ? reasoning : "";
+function resolveCompletionTokenCount(reportedTokenCount, response, reasoning) {
+  const reported = getUsageTokenCount(reportedTokenCount);
+  if (reported > 0) return reported;
+  return estimateCompletionTokensFallback(`${reasoning} ${response}`);
 }
 function asNonEmptyString(value) {
   if (typeof value !== "string") return void 0;
@@ -1090,11 +1198,17 @@ async function resolveLocalModelMetadata(modelId, apiModel, modelsRootDir) {
     const size = await readDirectorySizeBytes(source.fullPath);
     if (size > bestSize) bestSize = size;
     if (size > 0) {
-      return { size, parameterSize: definition.parameterSize };
+      return {
+        size,
+        parameterSize: definition.parameterSize
+      };
     }
   }
   if (bestSize > 0) {
-    return { size: bestSize, parameterSize: definition.parameterSize };
+    return {
+      size: bestSize,
+      parameterSize: definition.parameterSize
+    };
   }
   const fallback = await resolvePublisherModelMetadata(modelId, apiModel, modelsRootDir);
   if (fallback.size > 0) {
@@ -1103,7 +1217,10 @@ async function resolveLocalModelMetadata(modelId, apiModel, modelsRootDir) {
       parameterSize: definition.parameterSize ?? fallback.parameterSize
     };
   }
-  return { size: 0, parameterSize: definition.parameterSize ?? fallback.parameterSize };
+  return {
+    size: 0,
+    parameterSize: definition.parameterSize ?? fallback.parameterSize
+  };
 }
 function parseSizeBytes(model) {
   if (!model) return 0;
@@ -1141,6 +1258,21 @@ function inferParameterSizeFromModelId(modelId) {
   }
   return void 0;
 }
+function resolveModelFormat(apiModel, _localMetadata, _modelId) {
+  return asNonEmptyString(apiModel?.compatibility_type);
+}
+function buildModelEntry(id, apiModel, localMetadata) {
+  const apiSize = parseSizeBytes(apiModel);
+  return {
+    name: id,
+    size: apiSize > 0 ? apiSize : localMetadata?.size ?? 0,
+    parameterSize: localMetadata?.parameterSize ?? inferParameterSizeFromModelId(id),
+    quantization: asNonEmptyString(apiModel?.quantization),
+    runtimeStatus: asNonEmptyString(apiModel?.state),
+    modelFormat: resolveModelFormat(apiModel, localMetadata, id),
+    family: asNonEmptyString(apiModel?.arch) ?? asNonEmptyString(apiModel?.type) ?? asNonEmptyString(apiModel?.publisher)
+  };
+}
 function isLoadedState(state) {
   if (!state) return false;
   const normalized = state.trim().toLowerCase();
@@ -1148,6 +1280,128 @@ function isLoadedState(state) {
   if (normalized === "loaded" || normalized === "ready") return true;
   return normalized.includes("loaded");
 }
+function execFileText(cmd, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    execFile2(
+      cmd,
+      args,
+      {
+        timeout: timeoutMs,
+        maxBuffer: 1024 * 1024,
+        env: process.env
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          const error = err;
+          error.stdout = stdout;
+          error.stderr = stderr;
+          reject(error);
+          return;
+        }
+        resolve({ stdout, stderr });
+      }
+    );
+  });
+}
+function isCommandMissingError(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+async function runLmsCli(args) {
+  const configuredPath = asNonEmptyString(process.env[LM_STUDIO_CLI_PATH_ENV]);
+  const fallbackPath = path.join(getLMStudioHomeDir(), "bin", "lms");
+  const candidates = [
+    configuredPath,
+    "lms",
+    fallbackPath
+  ].filter(
+    (candidate, index, list) => Boolean(candidate) && list.indexOf(candidate) === index
+  );
+  let lastError;
+  for (const candidate of candidates) {
+    try {
+      return await execFileText(candidate, args, LM_STUDIO_CLI_TIMEOUT_MS);
+    } catch (err) {
+      lastError = err;
+      if (isCommandMissingError(err)) continue;
+      throw err;
+    }
+  }
+  throw lastError ?? new Error("LM Studio CLI is not available.");
+}
+function normalizeCliToken(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function matchesLoadedModelCliEntry(entry, model) {
+  const target = normalizeCliToken(model);
+  if (!target) return false;
+  return [
+    entry.identifier,
+    entry.indexedModelIdentifier,
+    entry.path,
+    entry.modelKey
+  ].some((candidate) => normalizeCliToken(candidate) === target);
+}
+async function listLoadedModelsFromCli() {
+  const { stdout } = await runLmsCli(["ps", "--json"]);
+  const parsed = JSON.parse(stdout);
+  return Array.isArray(parsed) ? parsed : [];
+}
+function parseEstimatedBytes(output4) {
+  const match = output4.match(/Estimated Total Memory:\s*([0-9]+(?:\.[0-9]+)?)\s*(KiB|MiB|GiB|TiB|KB|MB|GB|TB)/i);
+  if (!match) return null;
+  const value = Number.parseFloat(match[1] ?? "");
+  const unit = (match[2] ?? "").toUpperCase();
+  if (!Number.isFinite(value) || value <= 0) return null;
+  const multipliers = {
+    KIB: 1024,
+    MIB: 1024 ** 2,
+    GIB: 1024 ** 3,
+    TIB: 1024 ** 4,
+    KB: 1e3,
+    MB: 1e3 ** 2,
+    GB: 1e3 ** 3,
+    TB: 1e3 ** 4
+  };
+  const multiplier = multipliers[unit];
+  if (!multiplier) return null;
+  return Math.round(value * multiplier);
+}
+async function estimateLoadedModelMemoryBytes(model) {
+  let loadedEntry;
+  try {
+    const loadedModels = await listLoadedModelsFromCli();
+    loadedEntry = loadedModels.find((entry) => matchesLoadedModelCliEntry(entry, model));
+  } catch {
+    loadedEntry = void 0;
+  }
+  if (!loadedEntry) return null;
+  const candidateModelKeys = [
+    loadedEntry?.path,
+    loadedEntry?.indexedModelIdentifier,
+    loadedEntry?.modelKey
+  ].filter(
+    (candidate, index, list) => Boolean(candidate?.trim()) && list.findIndex((item) => item === candidate) === index
+  );
+  for (const candidate of candidateModelKeys) {
+    const args = ["load", "--estimate-only", "-y"];
+    if (typeof loadedEntry?.contextLength === "number" && Number.isFinite(loadedEntry.contextLength) && loadedEntry.contextLength > 0) {
+      args.push("--context-length", String(Math.trunc(loadedEntry.contextLength)));
+    }
+    args.push(candidate);
+    try {
+      const { stdout, stderr } = await runLmsCli(args);
+      const estimated = parseEstimatedBytes(`${stdout}
+${stderr}`);
+      if (estimated !== null) return estimated;
+    } catch (err) {
+      const output4 = err instanceof Error ? `${String(err.stdout ?? "")}
+${String(err.stderr ?? "")}` : "";
+      const estimated = parseEstimatedBytes(output4);
+      if (estimated !== null) return estimated;
+    }
+  }
+  return null;
+}
 async function fetchApiModels() {
   try {
     const resp = await fetchWithTimeout(
@@ -1200,7 +1454,7 @@ async function getLMStudioVersion() {
   const localVersion = await resolveLocalLMStudioVersion();
   try {
     const resp = await fetchWithTimeout(
-      "/v1/models",
+      "/api/v1/models",
       { method: "GET", headers: getLMStudioHeaders() },
       5e3,
       "LM Studio version check"
@@ -1215,7 +1469,7 @@ async function getLMStudioVersion() {
 }
 async function listModels2() {
   const resp = await fetchWithTimeout(
-    "/v1/models",
+    "/api/v1/models",
     { method: "GET", headers: getLMStudioHeaders() },
     LM_STUDIO_INIT_TIMEOUT_MS,
     "LM Studio list models"
@@ -1233,25 +1487,25 @@ async function listModels2() {
     apiById.set(id, model);
   }
   const modelsRootDir = await resolveModelsRootDir();
-  const localMetadataById = /* @__PURE__ */ new Map();
-  for (const id of ids) {
-    const localMetadata = await resolveLocalModelMetadata(id, apiById.get(id), modelsRootDir);
-    localMetadataById.set(id, localMetadata);
-  }
-  return ids.map((id) => {
-    const apiModel = apiById.get(id);
-    const localMetadata = localMetadataById.get(id);
-    const apiSize = parseSizeBytes(apiModel);
-    return {
-      name: id,
-      size: apiSize > 0 ? apiSize : localMetadata?.size ?? 0,
-      parameterSize: localMetadata?.parameterSize ?? inferParameterSizeFromModelId(id),
-      quantization: asNonEmptyString(apiModel?.quantization),
-      runtimeStatus: asNonEmptyString(apiModel?.state),
-      modelFormat: asNonEmptyString(apiModel?.compatibility_type),
-      family: asNonEmptyString(apiModel?.arch) ?? asNonEmptyString(apiModel?.type) ?? asNonEmptyString(apiModel?.publisher)
-    };
-  });
+  const localMetadataEntries = await Promise.all(
+    ids.map(async (id) => {
+      const localMetadata = await resolveLocalModelMetadata(id, apiById.get(id), modelsRootDir);
+      return [id, localMetadata];
+    })
+  );
+  const localMetadataById = new Map(
+    localMetadataEntries
+  );
+  return ids.map((id) => buildModelEntry(id, apiById.get(id), localMetadataById.get(id)));
+}
+async function resolveModel(modelId) {
+  const id = modelId.trim();
+  if (!id) return null;
+  const apiModels = await fetchApiModels();
+  const apiModel = apiModels?.find((candidate) => asNonEmptyString(candidate.id) === id);
+  const modelsRootDir = await resolveModelsRootDir();
+  const localMetadata = await resolveLocalModelMetadata(id, apiModel, modelsRootDir);
+  return buildModelEntry(id, apiModel, localMetadata);
 }
 async function listRunningModels2() {
   const apiModels = await fetchApiModels();
@@ -1272,11 +1526,11 @@ async function generate2(model, prompt, options) {
   activeAbortControllers.add(controller);
   try {
     const baseUrl = getLMStudioBaseUrl();
-    const url = new URL("/v1/chat/completions", baseUrl);
+    const url = new URL("/api/v1/chat", baseUrl);
     const doRequest = (includeSampling) => fetch(url, {
       method: "POST",
       headers: getLMStudioHeaders(),
-      body: JSON.stringify(buildChatCompletionBody(model, prompt, options, false, includeSampling)),
+      body: JSON.stringify(buildNativeChatBody(model, prompt, options, false, includeSampling)),
       signal: controller.signal
     });
     let resp = await doRequest(true);
@@ -1293,21 +1547,33 @@ async function generate2(model, prompt, options) {
       throw buildLMStudioRequestError("generate", model, resp.status, resp.statusText, body);
     }
     const payload = await resp.json();
-    const choice = extractChoice2(payload);
-    const response = extractContent(choice);
-    const reasoning = extractReasoning(choice);
+    const nativeResponse = extractNativeResponse(payload);
+    const response = nativeResponse.response;
+    const reasoning = nativeResponse.reasoning;
     assertThinkingModeRespected(model, options?.think, response, reasoning);
-    const usage = extractUsage(payload);
+    const stats = extractNativeStats(payload);
     const totalDuration = Math.max(0, Date.now() - start) * 1e6;
+    const outputTokens = getUsageTokenCount(stats?.total_output_tokens) || resolveCompletionTokenCount(void 0, response, reasoning);
+    const throughput = getNativeStatNumber(stats?.tokens_per_second);
+    const timeToFirstTokenSeconds = getNativeStatNumber(stats?.time_to_first_token_seconds);
+    const modelLoadTimeSeconds = getNativeStatNumber(stats?.model_load_time_seconds);
+    const evalCountEstimated = getUsageTokenCount(stats?.total_output_tokens) <= 0;
+    const evalDuration = throughput !== void 0 && throughput > 0 && outputTokens > 0 ? Math.max(1, Math.round(outputTokens / throughput * 1e9)) : totalDuration;
+    const promptEvalDuration = timeToFirstTokenSeconds !== void 0 ? Math.max(0, Math.round(timeToFirstTokenSeconds * 1e9)) : 0;
+    const loadDuration = Math.max(
+      0,
+      Math.round((modelLoadTimeSeconds ?? 0) * 1e9)
+    );
     return {
       response,
       ...reasoning ? { thinking: reasoning } : {},
       totalDuration,
-      loadDuration: 0,
-      promptEvalCount: usage?.prompt_tokens ?? 0,
-      promptEvalDuration: 0,
-      evalCount: usage?.completion_tokens ?? 0,
-      evalDuration: totalDuration
+      loadDuration,
+      promptEvalCount: getUsageTokenCount(stats?.input_tokens),
+      promptEvalDuration,
+      evalCount: outputTokens,
+      evalDuration,
+      ...evalCountEstimated ? { evalCountEstimated: true } : {}
     };
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
@@ -1322,10 +1588,10 @@ async function generateStream2(model, prompt, callbacks, options) {
   const start = Date.now();
   const controller = new AbortController();
   activeAbortControllers.add(controller);
-  const stallTimeoutMs = resolveStreamStallTimeoutMs(options?.stall_timeout_ms);
+  const stallTimeoutMs = resolveStreamStallTimeoutMs2(options?.stall_timeout_ms);
   let abortedByStallTimeout = false;
   const baseUrl = getLMStudioBaseUrl();
-  const url = new URL("/v1/chat/completions", baseUrl);
+  const url = new URL("/api/v1/chat", baseUrl);
   let stallTimer = null;
   const resetStallTimer = () => {
     if (stallTimeoutMs === void 0) return;
@@ -1340,7 +1606,7 @@ async function generateStream2(model, prompt, callbacks, options) {
     const doRequest = (includeSampling) => fetch(url, {
       method: "POST",
       headers: getLMStudioHeaders(),
-      body: JSON.stringify(buildChatCompletionBody(model, prompt, options, true, includeSampling)),
+      body: JSON.stringify(buildNativeChatBody(model, prompt, options, true, includeSampling)),
       signal: controller.signal
     });
     let resp = await doRequest(true);
@@ -1365,10 +1631,10 @@ async function generateStream2(model, prompt, callbacks, options) {
     let doneReceived = false;
     let fullResponse = "";
     let fullThinking = "";
-    let usage;
+    let stats;
     let firstChunkSeen = false;
-    let firstTokenTime = null;
-    let lastTokenTime = null;
+    let firstGeneratedTokenTime = null;
+    let lastGeneratedTokenTime = null;
     const processDataLine = (rawLine) => {
       const line = rawLine.trim();
       if (!line.startsWith("data:")) return;
@@ -1384,18 +1650,27 @@ async function generateStream2(model, prompt, callbacks, options) {
       } catch {
         return;
       }
-      const choice = extractChoice2(payload);
-      const content = extractContent(choice);
-      const reasoning = extractReasoning(choice);
-      const chunkUsage = extractUsage(payload);
-      if (chunkUsage) usage = chunkUsage;
+      const delta = extractNativeDelta(payload);
+      const content = delta.response;
+      const reasoning = delta.reasoning;
+      const chunkStats = extractNativeStats(payload);
+      if (chunkStats) stats = chunkStats;
+      const aggregate = extractNativeResponse(payload);
+      if (aggregate.response) {
+        fullResponse = aggregate.response;
+      }
+      if (aggregate.reasoning) {
+        fullThinking = aggregate.reasoning;
+      }
+      if (reasoning || content) {
+        const now = Date.now();
+        if (firstGeneratedTokenTime === null) firstGeneratedTokenTime = now;
+        lastGeneratedTokenTime = now;
+      }
       if (reasoning) {
         fullThinking += reasoning;
       }
       if (content) {
-        const now = Date.now();
-        if (firstTokenTime === null) firstTokenTime = now;
-        lastTokenTime = now;
         fullResponse += content;
         callbacks?.onToken?.(content);
       }
@@ -1415,6 +1690,14 @@ async function generateStream2(model, prompt, callbacks, options) {
         processDataLine(rawLine);
       }
     }
+    buffered += decoder.decode();
+    if (buffered.length > 0) {
+      const lines = buffered.split("\n");
+      buffered = lines.pop() ?? "";
+      for (const rawLine of lines) {
+        processDataLine(rawLine);
+      }
+    }
     if (buffered.trim().length > 0) {
       processDataLine(buffered);
     }
@@ -1423,16 +1706,25 @@ async function generateStream2(model, prompt, callbacks, options) {
       throw new Error("LM Studio stream ended without content");
     }
     const totalDuration = Math.max(0, Date.now() - start) * 1e6;
-    const evalDurationMs = firstTokenTime !== null && lastTokenTime !== null && lastTokenTime > firstTokenTime ? lastTokenTime - firstTokenTime : Date.now() - start;
+    const outputTokens = getUsageTokenCount(stats?.total_output_tokens) || resolveCompletionTokenCount(void 0, fullResponse, fullThinking);
+    const throughput = getNativeStatNumber(stats?.tokens_per_second);
+    const timeToFirstTokenSeconds = getNativeStatNumber(stats?.time_to_first_token_seconds);
+    const modelLoadTimeSeconds = getNativeStatNumber(stats?.model_load_time_seconds);
+    const evalCountEstimated = getUsageTokenCount(stats?.total_output_tokens) <= 0;
+    const evalDurationMs = throughput !== void 0 && throughput > 0 && outputTokens > 0 ? outputTokens / throughput * 1e3 : firstGeneratedTokenTime !== null && lastGeneratedTokenTime !== null && lastGeneratedTokenTime > firstGeneratedTokenTime ? lastGeneratedTokenTime - firstGeneratedTokenTime : Date.now() - start;
     const result = {
       response: fullResponse,
       ...fullThinking ? { thinking: fullThinking } : {},
       totalDuration,
-      loadDuration: 0,
-      promptEvalCount: usage?.prompt_tokens ?? 0,
-      promptEvalDuration: firstTokenTime !== null ? (firstTokenTime - start) * 1e6 : 0,
-      evalCount: usage?.completion_tokens ?? 0,
-      evalDuration: Math.max(1, evalDurationMs) * 1e6
+      loadDuration: Math.max(
+        0,
+        Math.round((modelLoadTimeSeconds ?? 0) * 1e9)
+      ),
+      promptEvalCount: getUsageTokenCount(stats?.input_tokens),
+      promptEvalDuration: timeToFirstTokenSeconds !== void 0 ? Math.max(0, Math.round(timeToFirstTokenSeconds * 1e9)) : firstGeneratedTokenTime !== null ? (firstGeneratedTokenTime - start) * 1e6 : 0,
+      evalCount: outputTokens,
+      evalDuration: Math.max(1, Math.round(evalDurationMs * 1e6)),
+      ...evalCountEstimated ? { evalCountEstimated: true } : {}
     };
     assertThinkingModeRespected(model, options?.think, fullResponse, fullThinking);
     callbacks?.onDone?.(result);
@@ -1600,6 +1892,19 @@ function getRuntimeName() {
 function getRuntimeModelFormat() {
   return activeRuntime.modelFormat ?? "gguf";
 }
+async function resolveRuntimeModel(model) {
+  if (activeRuntime.name === "lm-studio") {
+    return resolveModel(model);
+  }
+  const knownModels = await activeRuntime.listModels();
+  const matchedModel = knownModels.find((candidate) => candidate.name === model);
+  if (matchedModel) return matchedModel;
+  return {
+    name: model,
+    size: 0,
+    modelFormat: activeRuntime.modelFormat ?? "gguf"
+  };
+}
 
 // ../src/commands/bench.ts
 import { createHash as createHash3 } from "crypto";
@@ -1608,11 +1913,33 @@ import chalk8 from "chalk";
 // ../src/core/hardware.ts
 import si from "systeminformation";
 import os2 from "os";
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { readFile } from "fs/promises";
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function looksLikeGpuDescriptor(value) {
+  return /\b(radeon|graphics|geforce|rtx|gtx|arc|iris|uhd|quadro|tesla|adreno|mali|powervr)\b/i.test(value);
+}
+function splitCpuAndInferredGpu(cpuLabel) {
+  const normalized = normalizeWhitespace(cpuLabel);
+  const withGpuMatch = normalized.match(/\s+(?:w\/\s*|with\s+)(.+)$/i);
+  if (!withGpuMatch?.index) {
+    return { cpu: normalized, inferredGpu: null };
+  }
+  const inferredGpu = normalizeWhitespace(withGpuMatch[1] ?? "");
+  if (!looksLikeGpuDescriptor(inferredGpu)) {
+    return { cpu: normalized, inferredGpu: null };
+  }
+  const cpu = normalizeWhitespace(normalized.slice(0, withGpuMatch.index));
+  return {
+    cpu: cpu || normalized,
+    inferredGpu: inferredGpu || null
+  };
+}
 function execCommand(cmd, args, timeoutMs = 3e3) {
   return new Promise((resolve) => {
-    const child = execFile2(cmd, args, { timeout: timeoutMs }, (err, stdout) => {
+    const child = execFile3(cmd, args, { timeout: timeoutMs }, (err, stdout) => {
       if (err) return resolve("");
       resolve(stdout.trim());
     });
@@ -1746,11 +2073,14 @@ async function getHardwareInfo() {
   ]);
   const gpuController = graphics.controllers[0];
   const gpuNames = graphics.controllers.map((g) => g.model).filter(Boolean).join(", ");
+  const cpuLabelRaw = normalizeWhitespace(`${cpu.manufacturer} ${cpu.brand}`);
+  const { cpu: cpuLabel, inferredGpu } = splitCpuAndInferredGpu(cpuLabelRaw);
+  const defaultIntegratedGpu = process.platform === "darwin" ? "Integrated / Apple Silicon" : "Integrated / Unknown";
   const gpuCoresRaw = gpuController?.cores;
   const gpuCores = gpuCoresRaw ? parseInt(String(gpuCoresRaw), 10) : null;
   const memType = memLayout.length > 0 ? memLayout[0].type : null;
   return {
-    cpu: `${cpu.manufacturer} ${cpu.brand}`,
+    cpu: cpuLabel,
     cpuCores: cpu.cores,
     cpuPCores: cpu.performanceCores || null,
     cpuECores: cpu.efficiencyCores || null,
@@ -1760,7 +2090,7 @@ async function getHardwareInfo() {
     memoryType: memType || null,
     swapTotalGB: +(mem.swaptotal / 1024 / 1024 / 1024).toFixed(1),
     swapUsedGB: +(mem.swapused / 1024 / 1024 / 1024).toFixed(1),
-    gpu: gpuNames || "Integrated / Apple Silicon",
+    gpu: normalizeWhitespace(gpuNames) || inferredGpu || defaultIntegratedGpu,
     gpuCores: gpuCores && !isNaN(gpuCores) ? gpuCores : null,
     gpuVramMB: gpuController?.vram ?? null,
     os: `${osInfo.distro} ${osInfo.release}`,
@@ -1795,6 +2125,10 @@ import chalk from "chalk";
 
 // ../src/ui/terminal.ts
 var supportsUnicode = process.platform !== "win32" || Boolean(process.env.WT_SESSION) || Boolean(process.env.TERM_PROGRAM);
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function stripAnsi(value) {
+  return value.replace(ANSI_RE, "");
+}
 
 // ../src/ui/progress.ts
 var FUN_PHRASES = [
@@ -1995,6 +2329,8 @@ async function runPerformanceBench(model, options = {}) {
       optionalProbeWithAvailability(() => getSwapUsedGB(), 0),
       optionalProbe(() => detectBatteryPowered(), void 0)
     ]);
+    const runningModelsBeforeWarmup = await optionalProbe(() => listRunningModels3(), []);
+    const modelWasAlreadyLoaded = runningModelsBeforeWarmup.some((m) => m.name === model);
     const warmup = await withTimeout(
       generateStream3(model, WARMUP_PROMPT, void 0, {
         ...withBenchmarkProfile({
@@ -2012,15 +2348,6 @@ async function runPerformanceBench(model, options = {}) {
     const loadTime = warmup.loadDuration / 1e6;
     const runningModels = await listRunningModels3();
     const thisModel = runningModels.find((m) => m.name === model);
-    let installedModelSizeBytes = 0;
-    try {
-      const availableModels = await listModels3();
-      const listedModel = availableModels.find((m) => m.name === model);
-      if (listedModel && Number.isFinite(listedModel.size) && listedModel.size > 0) {
-        installedModelSizeBytes = listedModel.size;
-      }
-    } catch {
-    }
     spinner.succeed("Model loaded");
     const tpsValues = [];
     const firstChunkValues = [];
@@ -2034,6 +2361,7 @@ async function runPerformanceBench(model, options = {}) {
     let thinkingDetected = false;
     let totalThinkingTokens = 0;
     const cpuLoadSamples = [];
+    let tokensPerSecondEstimated = false;
     for (let i = 0; i < BENCH_PROMPTS.length; i++) {
       spinner.start(`Running performance test ${i + 1}/${BENCH_PROMPTS.length}...`);
       let firstChunkTime = null;
@@ -2071,6 +2399,9 @@ async function runPerformanceBench(model, options = {}) {
         tpsValues.push(tps);
         totalEvalCount += result.evalCount;
         totalEvalDurationNs += result.evalDuration;
+        if (result.evalCountEstimated) {
+          tokensPerSecondEstimated = true;
+        }
         if (firstChunkTime !== null) {
           firstChunkValues.push(firstChunkTime);
         }
@@ -2116,10 +2447,18 @@ async function runPerformanceBench(model, options = {}) {
     ]);
     let memoryUsedGB;
     let memoryPercent;
-    const loadedModelSizeBytes = thisModel && thisModel.size > 0 ? thisModel.size : installedModelSizeBytes;
+    let memoryFootprintEstimated = false;
+    const runtimeReportsComparableLoadedSize = runtimeName !== "lm-studio";
+    const estimatedLoadedModelSizeBytes = runtimeName === "lm-studio" && modelWasAlreadyLoaded ? await optionalProbe(() => estimateLoadedModelMemoryBytes(model), null) : null;
+    const loadedModelSizeBytes = runtimeReportsComparableLoadedSize && thisModel && thisModel.size > 0 ? thisModel.size : 0;
+    const memoryFootprintAvailable = runtimeReportsComparableLoadedSize ? loadedModelSizeBytes > 0 || !modelWasAlreadyLoaded : (estimatedLoadedModelSizeBytes ?? 0) > 0 || !modelWasAlreadyLoaded;
     if (loadedModelSizeBytes > 0) {
       memoryUsedGB = loadedModelSizeBytes / 1024 ** 3;
       memoryPercent = memoryUsedGB / memAfter.totalGB * 100;
+    } else if ((estimatedLoadedModelSizeBytes ?? 0) > 0) {
+      memoryUsedGB = (estimatedLoadedModelSizeBytes ?? 0) / 1024 ** 3;
+      memoryPercent = memoryUsedGB / memAfter.totalGB * 100;
+      memoryFootprintEstimated = true;
     } else {
       memoryUsedGB = Math.max(0, memAfter.usedGB - memBefore.usedGB);
       memoryPercent = Math.max(0, memAfter.percent - memBefore.percent);
@@ -2141,6 +2480,7 @@ async function runPerformanceBench(model, options = {}) {
     return {
       metrics: {
         tokensPerSecond: totalEvalDurationNs > 0 ? totalEvalCount / (totalEvalDurationNs / 1e9) : avg(tpsValues),
+        ...tokensPerSecondEstimated ? { tokensPerSecondEstimated: true } : {},
         ...firstChunkMs !== void 0 ? { firstChunkMs } : {},
         ttft: ttft >= 0 ? ttft : 3e4,
         // Fallback: 30s if no TTFT measured
@@ -2151,6 +2491,8 @@ async function runPerformanceBench(model, options = {}) {
         completionTokens: totalCompletionTokens,
         memoryUsedGB: +memoryUsedGB.toFixed(1),
         memoryPercent: +memoryPercent.toFixed(1),
+        memoryFootprintAvailable,
+        ...memoryFootprintEstimated ? { memoryFootprintEstimated: true } : {},
         memoryHostUsedGB: memAfter.usedGB,
         memoryHostPercent: memAfter.percent,
         tpsStdDev: tpsValues.length >= 2 ? stddev(tpsValues) : void 0,
@@ -2915,7 +3257,7 @@ Answer:`;
 
 // ../src/benchmarks/coding.ts
 import vm2 from "vm";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { Worker } from "worker_threads";
 
 // ../src/datasets/coding.json
@@ -6588,7 +6930,7 @@ async function runTestsInSubprocess(code, task) {
   const total = task.tests.length;
   return new Promise((resolve) => {
     const wallTimeoutMs = computeIsolatedWallTimeoutMs(task);
-    const child = spawn(
+    const child = spawn2(
       process.execPath,
       [
         "--max-old-space-size=96",
@@ -7891,13 +8233,15 @@ function computePerformanceScore(perf, hardware) {
   const tuning = deriveHardwareFitTuning(hardware);
   const safeTokensPerSecond = sanitizeNonNegative(perf.tokensPerSecond, 0);
   const safeTtft = sanitizeNonNegative(perf.ttft, tuning.ttft.hardMaxMs * 2);
-  const effectiveMemPercent = sanitizeNonNegative(
-    perf.memoryHostPercent ?? perf.memoryPercent,
-    100
-  );
   const speed = Math.round(scoreSpeed(safeTokensPerSecond, tuning));
   const ttft = Math.round(scoreTTFT(safeTtft, tuning));
-  const memory = Math.round(scoreMemory(effectiveMemPercent));
+  const memory = perf.memoryFootprintAvailable === false ? Math.round((speed + ttft) / (50 + 20) * 30) : Math.round(
+    scoreMemory(
+      // Score memory from the model's measured footprint/delta rather than
+      // unrelated host RAM usage from other running workloads.
+      sanitizeNonNegative(perf.memoryPercent, 100)
+    )
+  );
   return {
     total: clamp(speed + ttft + memory, 0, 100),
     speed,
@@ -8006,11 +8350,9 @@ function computeFitness(perf, quality, hardware, benchEnv) {
   const safeTokensPerSecond = sanitizeNonNegative(perf.tokensPerSecond, 0);
   const safeTtft = sanitizeNonNegative(perf.ttft, tuning.ttft.hardMaxMs * 10);
   const safeLoadTime = sanitizeNonNegative(perf.loadTime, tuning.loadTimeHardMaxMs * 10);
-  const hostMemoryPercent = sanitizeNonNegative(
-    perf.memoryHostPercent ?? perf.memoryPercent,
-    100
-  );
-  const modelMemoryDeltaPercent = sanitizeNonNegative(perf.memoryPercent, 100);
+  const modelMemoryFootprintAvailable = perf.memoryFootprintAvailable !== false;
+  const modelMemoryDeltaPercent = modelMemoryFootprintAvailable ? sanitizeNonNegative(perf.memoryPercent, 100) : void 0;
+  const hostMemoryPercent = perf.memoryHostPercent !== void 0 && Number.isFinite(perf.memoryHostPercent) && perf.memoryHostPercent >= 0 ? perf.memoryHostPercent : void 0;
   const disqualifiers = [];
   if (safeTokensPerSecond < tuning.speed.hardMin) {
     disqualifiers.push(
@@ -8027,12 +8369,12 @@ function computeFitness(perf, quality, hardware, benchEnv) {
       `Model load time too high: ${Math.round(safeLoadTime)}ms (maximum: ${tuning.loadTimeHardMaxMs}ms for ${tuning.profile} profile)`
     );
   }
-  const hostCritical = hostMemoryPercent > 95;
-  const modelDeltaCritical = modelMemoryDeltaPercent > 90;
-  const modelDeltaSignificant = modelMemoryDeltaPercent >= 10;
-  if (modelDeltaCritical || hostCritical && modelDeltaSignificant) {
+  const hostCritical = hostMemoryPercent !== void 0 && hostMemoryPercent > 95;
+  const modelDeltaCritical = modelMemoryDeltaPercent !== void 0 && modelMemoryDeltaPercent > 90;
+  const modelDeltaSignificant = modelMemoryDeltaPercent !== void 0 && modelMemoryDeltaPercent >= 10;
+  if (modelDeltaCritical) {
     disqualifiers.push(
-      `Memory usage critical: host ${hostMemoryPercent.toFixed(0)}%, model delta +${modelMemoryDeltaPercent.toFixed(0)}%`
+      `Memory usage critical: model delta +${modelMemoryDeltaPercent.toFixed(0)}%`
     );
   }
   const verdictScore = globalScore ?? hardwareFitScore;
@@ -8067,9 +8409,28 @@ function computeFitness(perf, quality, hardware, benchEnv) {
       `Token speed is unstable (stddev ${perf.tpsStdDev.toFixed(1)} tok/s, mean ${safeTokensPerSecond.toFixed(1)} tok/s) \u2014 may indicate thermal throttling or memory pressure.`
     );
   }
-  if (hostCritical && !modelDeltaSignificant) {
+  if (perf.tokensPerSecondEstimated) {
+    warnings.push(
+      "Token throughput is estimated from LM Studio output because native token stats were unavailable. Compare tok/s across backends cautiously."
+    );
+  }
+  if (perf.memoryFootprintEstimated) {
     warnings.push(
-      `Host memory is already high (${hostMemoryPercent.toFixed(0)}%) but model delta is limited (+${modelMemoryDeltaPercent.toFixed(0)}%). Verdict may be influenced by other running workloads.`
+      "Model memory footprint is estimated via LM Studio CLI rather than measured from a fresh load."
+    );
+  }
+  if (!modelMemoryFootprintAvailable) {
+    warnings.push(
+      "Model memory footprint was unavailable for this run, so RAM fit scoring was normalized from speed and TTFT only."
+    );
+  }
+  if (hostCritical && !modelMemoryFootprintAvailable) {
+    warnings.push(
+      `Host memory is already high (${hostMemoryPercent.toFixed(0)}%) and model footprint was unavailable. Results may be influenced by other running workloads.`
+    );
+  } else if (hostCritical && modelMemoryDeltaPercent !== void 0 && !modelDeltaSignificant) {
+    warnings.push(
+      `Host memory is already high (${hostMemoryPercent.toFixed(0)}%) but model delta is limited (+${modelMemoryDeltaPercent.toFixed(0)}%). Results may be influenced by other running workloads.`
     );
   }
   if (hardware?.powerMode === "low-power") {
@@ -8157,6 +8518,21 @@ function getLevel(score) {
   if (score >= 25) return "Weak";
   return "Poor";
 }
+function formatCpuCoresLabel(hw) {
+  if (hw.cpuPCores !== null && hw.cpuECores !== null) {
+    return `${hw.cpuCores} total (${hw.cpuPCores} performance + ${hw.cpuECores} efficiency)`;
+  }
+  if (hw.cpuPCores !== null && hw.cpuCores > hw.cpuPCores) {
+    return `${hw.cpuCores} threads (${hw.cpuPCores} cores)`;
+  }
+  if (hw.cpuPCores !== null) {
+    return `${hw.cpuCores} total (${hw.cpuPCores} performance)`;
+  }
+  if (hw.cpuECores !== null) {
+    return `${hw.cpuCores} total (${hw.cpuECores} efficiency)`;
+  }
+  return String(hw.cpuCores);
+}
 function summarizeCategoryIssues(name, details) {
   let crashes = 0;
   let timeouts = 0;
@@ -8181,7 +8557,7 @@ function printHardwareTable(hw) {
     head: [chalk3.bold("Hardware"), chalk3.bold("Value")],
     style: { head: [], border: [] }
   });
-  const coresDetail = hw.cpuPCores ? `${hw.cpuCores} (${hw.cpuPCores} performance + ${hw.cpuECores ?? 0} efficiency)` : String(hw.cpuCores);
+  const coresDetail = formatCpuCoresLabel(hw);
   const cpuLine = hw.cpuFreqGHz ? `${hw.cpu} @ ${hw.cpuFreqGHz} GHz` : hw.cpu;
   const ramLine = hw.memoryType ? `${hw.totalMemoryGB} GB ${hw.memoryType} (${hw.freeMemoryGB} GB free)` : `${hw.totalMemoryGB} GB (${hw.freeMemoryGB} GB free)`;
   const swapColor = hw.swapUsedGB > hw.swapTotalGB * 0.5 ? chalk3.yellow : chalk3.green;
@@ -8217,7 +8593,10 @@ function printPerformanceTable(perf, benchEnvironment) {
   const ttftColor = perf.ttft < 1e3 ? chalk3.green : perf.ttft < 3e3 ? chalk3.yellow : chalk3.red;
   const memColor = perf.memoryPercent < 50 ? chalk3.green : perf.memoryPercent < 80 ? chalk3.yellow : chalk3.red;
   table.push(
-    ["Tokens/sec", tpsColor(`${perf.tokensPerSecond.toFixed(1)} tok/s`)],
+    [
+      "Tokens/sec",
+      perf.tokensPerSecondEstimated ? chalk3.yellow(`${perf.tokensPerSecond.toFixed(1)} tok/s (estimated)`) : tpsColor(`${perf.tokensPerSecond.toFixed(1)} tok/s`)
+    ],
     [
       "First Chunk Latency",
       perf.firstChunkMs !== void 0 ? formatDuration(perf.firstChunkMs) : chalk3.dim("N/A (stream metric unavailable)")
@@ -8232,8 +8611,8 @@ function printPerformanceTable(perf, benchEnvironment) {
     ["Completion Tokens", String(perf.completionTokens)],
     [
       "Model Memory Footprint",
-      memColor(
-        `${perf.memoryUsedGB.toFixed(1)} GB (+${perf.memoryPercent.toFixed(0)}%)`
+      perf.memoryFootprintAvailable === false ? chalk3.dim("N/A (model already loaded; runtime metric unavailable)") : memColor(
+        `${perf.memoryUsedGB.toFixed(1)} GB (+${perf.memoryPercent.toFixed(0)}%)${perf.memoryFootprintEstimated ? " (estimated)" : ""}`
       )
     ],
     [
@@ -8319,7 +8698,7 @@ function printSummaryTable(results) {
     chalk3.bold("Model"),
     chalk3.bold("tok/s"),
     chalk3.bold("TTFT"),
-    chalk3.bold("Host RAM%"),
+    chalk3.bold("Model RAM%"),
     chalk3.bold("Profile"),
     chalk3.bold("HW Fit"),
     chalk3.bold("Quality"),
@@ -8332,17 +8711,23 @@ function printSummaryTable(results) {
     style: { head: [], border: [] },
     wordWrap: true
   });
+  const formatSummaryModelMemory = (result) => {
+    if (result.performance.memoryFootprintAvailable === false) return "N/A";
+    const value = `${result.performance.memoryPercent.toFixed(0)}%`;
+    return result.performance.memoryFootprintEstimated ? `${value}~` : value;
+  };
   for (const r of results) {
     const vColor = r.fitness.verdict === "EXCELLENT" ? chalk3.green.bold : r.fitness.verdict === "GOOD" ? chalk3.blue.bold : r.fitness.verdict === "MARGINAL" ? chalk3.yellow.bold : chalk3.red.bold;
     const flags = [];
     if (r.hardware.powerMode === "low-power") flags.push(chalk3.red("ECO"));
     if (r.modelInfo?.thinkingDetected) flags.push(chalk3.magenta("THINK"));
     const modelName = compact && r.model.length > 20 ? r.model.slice(0, 18) + ".." : r.model;
+    const throughputLabel = r.performance.tokensPerSecondEstimated ? `~${r.performance.tokensPerSecond.toFixed(1)}` : `${r.performance.tokensPerSecond.toFixed(1)}`;
     const row = [
       modelName,
-      `${r.performance.tokensPerSecond.toFixed(1)}`,
+      throughputLabel,
       formatDuration(r.performance.ttft),
-      r.performance.memoryHostPercent !== void 0 ? `${r.performance.memoryHostPercent.toFixed(0)}%` : "n/a",
+      formatSummaryModelMemory(r),
       r.fitness.tuning.profile,
       scoreColor(r.fitness.hardwareFitScore)(
         `${compactBar(r.fitness.hardwareFitScore)} ${r.fitness.hardwareFitScore}%`
@@ -8367,9 +8752,8 @@ function printSummaryTable(results) {
 // ../src/ui/verdict.ts
 import chalk4 from "chalk";
 var BOX_INNER = 60;
-var ANSI_RE = /\x1b\[[0-9;]*m/g;
 function visibleLength(str) {
-  return str.replace(ANSI_RE, "").length;
+  return stripAnsi(str).length;
 }
 function wrapText(text, maxWidth) {
   if (visibleLength(text) <= maxWidth) return [text];
@@ -8739,6 +9123,15 @@ function assertUploaderConfig(config) {
     );
   }
 }
+function resolveUploadedMemoryPercent(result) {
+  return result.performance.memoryFootprintAvailable === false ? null : result.performance.memoryPercent;
+}
+function resolveUploadedModelFormat(result) {
+  if (result.metadata.modelFormat?.trim()) return result.metadata.modelFormat;
+  const runtimeBackend = result.metadata.runtimeBackend ?? "ollama";
+  if (runtimeBackend === "ollama") return "gguf";
+  return "unknown";
+}
 async function uploadBenchResult(result, options = {}) {
   const config = resolveUploaderConfig();
   assertUploaderConfig(config);
@@ -8751,7 +9144,7 @@ async function uploadBenchResult(result, options = {}) {
     thinking_detected: result.modelInfo?.thinkingDetected ?? null,
     tokens_per_second: result.performance.tokensPerSecond,
     ttft_ms: result.performance.ttft,
-    memory_percent: result.performance.memoryHostPercent ?? result.performance.memoryPercent,
+    memory_percent: resolveUploadedMemoryPercent(result),
     thinking_tokens_estimate: result.performance.thinkingTokensEstimate ?? null,
     verdict: result.fitness.verdict,
     global_score: result.fitness.globalScore,
@@ -8768,7 +9161,7 @@ async function uploadBenchResult(result, options = {}) {
     benchmark_spec_version: result.metadata.benchmarkSpecVersion,
     runtime_version: result.metadata.runtimeVersion,
     runtime_backend: result.metadata.runtimeBackend ?? "ollama",
-    model_format: result.metadata.modelFormat ?? "gguf",
+    model_format: resolveUploadedModelFormat(result),
     raw_log_hash: result.metadata.rawLogHash,
     result
   };
@@ -9021,6 +9414,7 @@ async function promptSubmitterProfile(deps, defaults = {}) {
     }
     console.log(chalk6.yellow("Nickname must be between 2 and 40 characters."));
   }
+  console.log(chalk6.dim("Your email is never stored \u2014 only a SHA-256 hash is saved to match your leaderboard entries."));
   while (true) {
     const emailHint = defaults.email ? ` [${defaults.email}]` : "";
     const emailAnswer = await ask(`Email${emailHint} > `);
@@ -9308,7 +9702,7 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
           minSuccessfulPrompts: options.perfMinSuccessfulPrompts,
           failOnPromptError: options.perfStrict,
           think: thinkEnabled,
-          streamStallTimeoutMs: options.lmStudioStreamStallTimeoutMs
+          streamStallTimeoutMs: options.streamStallTimeoutMs
         });
         const perf = perfResult.metrics;
         const benchEnvironment = perfResult.benchEnvironment;
@@ -9346,13 +9740,22 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
           printVerdict(modelName, fitness);
         }
         const matchedModel = allModels.find((m) => m.name === modelName);
-        const modelInfo = matchedModel ? {
-          parameterSize: matchedModel.parameterSize,
-          quantization: matchedModel.quantization,
-          family: matchedModel.family,
-          // Persist the configured benchmark mode (not model auto-detection).
-          thinkingDetected: thinkEnabled
-        } : { thinkingDetected: thinkEnabled };
+        let resolvedModel = matchedModel;
+        if (matchedModel?.modelFormat === void 0) {
+          try {
+            resolvedModel = await resolveRuntimeModel(modelName) ?? matchedModel;
+          } catch {
+            resolvedModel = matchedModel;
+          }
+        }
+        const modelMetadataSource = resolvedModel ?? matchedModel;
+        const modelInfo = modelMetadataSource ? {
+          parameterSize: modelMetadataSource.parameterSize,
+          quantization: modelMetadataSource.quantization,
+          family: modelMetadataSource.family,
+          // Persist actual observed thinking behavior from the benchmark run.
+          thinkingDetected: perfResult.thinkingDetected
+        } : { thinkingDetected: perfResult.thinkingDetected };
         const partialResult = {
           model: modelName,
           modelInfo,
@@ -9367,7 +9770,7 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
             promptPackVersion: PROMPT_PACK_VERSION,
             runtimeVersion,
             runtimeBackend: getRuntimeName(),
-            modelFormat: matchedModel?.modelFormat ?? getRuntimeModelFormat(),
+            modelFormat: resolvedModel?.modelFormat ?? (getRuntimeName() === "ollama" ? getRuntimeModelFormat() : "unknown"),
             benchmarkProfile: buildBenchmarkProfileMetadata(thinkEnabled)
           }
         };