offgrid-ai 0.16.3 → 0.17.0

package/src/profile-setup.mjs

@@ -14,12 +14,28 @@ import { detectOmlxMtpCapability, findOmlxModelDir } from "./mlx-discovery.mjs";
 const execFileAsync = promisify(execFile);
 
 const CACHE_CHOICES = [
-  { value: "bf16", label: "bf16", hint: "default: stable, good quality" },
-  { value: "f16", label: "f16", hint: "stable fallback, similar memory to bf16" },
-  { value: "q8_0", label: "q8_0", hint: "lower memory, usually safe" },
-  { value: "q4_0", label: "q4_0", hint: "lowest memory, quality/speed tradeoff" },
+  { value: "bf16", label: "bf16", hint: "16-bit · best quality · 2 bytes/elem" },
+  { value: "f16", label: "f16", hint: "16-bit · stable fallback · 2 bytes/elem" },
+  { value: "q8_0", label: "q8_0", hint: "8-bit · half memory · usually safe · 1 byte/elem" },
+  { value: "q4_0", label: "q4_0", hint: "4-bit · quarter memory · quality tradeoff · 0.5 bytes/elem" },
 ];
 
+function quickKvBytes(modelPath, flags) {
+  try {
+    return estimateMemory(modelPath, null, null, flags).kvBytes;
+  } catch {
+    return 0;
+  }
+}
+
+function cacheMemoryRows(modelPath, flags, ctxSize) {
+  const combos = [["bf16", "bf16"], ["f16", "f16"], ["q8_0", "q8_0"], ["q4_0", "q4_0"]];
+  return combos.map(([k, v]) => {
+    const bytes = quickKvBytes(modelPath, { ...flags, ctxSize, cacheTypeK: k, cacheTypeV: v });
+    return [`${k}/${v} KV cache`, bytes ? `~${formatBytes(bytes)}` : "unknown"];
+  });
+}
+
 const GENERAL_DEFAULTS = {
   topK: 20,
   presencePenalty: 1.5,
@@ -40,7 +56,6 @@ export async function configureLocalProfile(prompt, profile) {
   const freshCaps = detectCapabilities(profile.modelPath, profile.mmprojPath);
   let drafterPath = profile.drafterPath ?? null;
   if (drafterPath && !existsSync(drafterPath)) {
-    // Stored drafter is no longer on disk — drop it and re-scan for a fresh one.
     drafterPath = null;
   }
   if (!drafterPath) {
@@ -50,86 +65,229 @@ export async function configureLocalProfile(prompt, profile) {
   }
   const hasMtp = freshCaps.mtp || Boolean(drafterPath);
   const caps = { ...freshCaps, mtp: hasMtp };
-  // MTP is a capability, not a separate backend. Just update the profile's
-  // capabilities and drafter path — flag computation handles the rest.
   configured = { ...configured, drafterPath: drafterPath ?? null, capabilities: { ...configured.capabilities, mtp: hasMtp } };
-  // If vision was previously disabled but mmproj is back, re-enable
   if (configured.disabledMmprojPath && configured.mmprojPath === null && freshCaps.vision) {
     configured = { ...configured, mmprojPath: configured.disabledMmprojPath, disabledMmprojPath: undefined, capabilities: { ...configured.capabilities, vision: true, visionDisabledReason: undefined } };
   }
 
+  // ── Model overview ──────────────────────────────────────────────────────
   console.log("");
-  console.log(renderSection("Model setup", renderRows([
+  console.log(renderSection("Model overview", renderRows([
     ["Model", pc.bold(profile.label)],
     ["Detected", capabilitySummary(caps)],
-    ["Context", `${profile.flags.ctxSize.toLocaleString()} tokens`],
-    ["KV cache", `${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV}`],
-    ["Sampling", samplingSummary(profile.flags)],
+    ["Backend", "llama.cpp (local server)"],
+    ["Model file", profile.modelPath],
   ])));
-  console.log(pc.dim("Larger context windows use more memory. KV cache precision controls memory used by attention history."));
-  console.log(pc.dim("Sampling defaults are shown for transparency; you can edit the profile later if needed.\n"));
 
+  // ── MTP ────────────────────────────────────────────────────────────────
   if (caps.mtp) {
-    const drafterInfo = configured.drafterPath ? `\n  Drafter: ${configured.drafterPath}` : "";
-    console.log(renderSection("MTP detected", renderRows([
-      ["Feature", "Multi-Token Prediction (speculative decoding)"],
-      ["Flags", `--spec-type draft-mtp --spec-draft-n-max 4${configured.drafterPath ? " --spec-draft-model <drafter>" : ""}`],
-    ])));
-    if (drafterInfo) console.log(pc.dim(drafterInfo));
-    const useMtp = await prompt.yesNo("Use MTP speculative decoding?", true);
-    configured = useMtp ? applyMtpDefaults(configured) : removeMtpDefaults(configured);
-  }
-
-  if (caps.qat) {
     console.log("");
-    console.log(renderSection("QAT detected", renderRows([
-      ["Meaning", "quantization-aware trained"],
-      ["Runtime flags", "none QAT-specific"],
+    console.log(renderSection("MTP (Multi-Token Prediction)", renderRows([
+      ["What it does", "Speculative decoding — predicts multiple tokens at once, verifies them"],
+      ["Speed", "1.5–3x faster generation"],
+      ["Quality", "No loss — rejected predictions fall back to normal"],
+      ["Memory", "Slightly more for draft model weights"],
+      ["Flags", "--spec-type draft-mtp --spec-draft-n-max 4"],
+      ...(configured.drafterPath ? [["Drafter", configured.drafterPath]] : []),
     ])));
+    const useMtp = await prompt.yesNo("Enable MTP speculative decoding?", true);
+    configured = useMtp ? applyMtpDefaults(configured) : removeMtpDefaults(configured);
   }
 
+  // ── Vision ─────────────────────────────────────────────────────────────
   if (caps.vision && profile.mmprojPath) {
     console.log("");
     const gemma4Unified = isGemma4UnifiedProjector(caps.mmprojProjectorType);
     const supported = !gemma4Unified || await runtimeSupportsGemma4Unified();
-    console.log(renderSection("Vision projector detected", renderRows([
-      ["Projector", caps.mmprojProjectorType ?? "unknown"],
+    console.log(renderSection("Vision projector", renderRows([
+      ["What it does", "Enables image understanding — model can see and reason about images"],
+      ["Projector type", caps.mmprojProjectorType ?? "unknown"],
       ["Flag", `--mmproj ${profile.mmprojPath}`],
+      ["Memory", "~200 MB for projector weights (varies by model)"],
       ...(gemma4Unified && !supported ? [["Note", pc.yellow("Gemma 4 unified projectors need llama.cpp b9549+.")]] : []),
     ])));
-    const useVision = await prompt.yesNo("Enable vision with --mmproj?", supported);
+    const useVision = await prompt.yesNo("Enable vision?", supported);
     configured = useVision ? applyVisionDefaults(configured) : removeVisionDefaults(configured, gemma4Unified && !supported ? "gemma4-unified-unsupported" : "user-disabled");
   }
 
+  // ── Thinking ───────────────────────────────────────────────────────────
   if (caps.thinking) {
     console.log("");
-    console.log(renderSection("Thinking model detected", renderRows([
-      ["Defaults", "thinking / loop-safe"],
-      ["Flags", "--top-k 64 --presence-penalty 0 --repeat-penalty 1.1"],
+    console.log(renderSection("Thinking mode", renderRows([
+      ["What it does", "Model reasons step-by-step before answering"],
+      ["Benefit", "Better results for math, code, logic — but slower (more output tokens)"],
+      ["Sampling changes", "top-k → 64, presence penalty → 0, repeat penalty → 1.1 (adjustable below)"],
       ["Template", "--chat-template-kwargs { enable_thinking: true }"],
     ])));
-    const useThinking = await prompt.yesNo("Use these thinking/loop-safe defaults?", true);
+    const useThinking = await prompt.yesNo("Use thinking/loop-safe defaults?", true);
     configured = useThinking ? applyThinkingDefaults(configured) : removeThinkingDefaults(configured);
   }
 
-  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, 1048576);
+  // ── Context window ─────────────────────────────────────────────────────
+  const maxCtx = caps.metaCtx ?? 1048576;
+  console.log("");
+  console.log(renderSection("Context window", renderRows([
+    ["What it does", "Maximum tokens the model can process at once (prompt + response + history)"],
+    ["Range", `1,024 – ${maxCtx.toLocaleString()} tokens`],
+    ["Memory", "KV cache grows linearly — larger context = more RAM"],
+    ["Guidance", "8k–32k: chat · 32k–80k: coding/long convos · 128k+: long documents"],
+    ["Model max", `${maxCtx.toLocaleString()} tokens`],
+    ["Default", `${configured.flags.ctxSize.toLocaleString()} tokens`],
+  ])));
+  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, maxCtx);
+  configured = applyRuntimeFlagOverrides(configured, { ctxSize });
+
+  // ── K cache precision ──────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("K cache precision", renderRows([
+    ["What it is", "KV cache stores attention 'keys' — previous token states used for prediction"],
+    ["Tradeoff", "Lower precision = less memory, potential quality loss"],
+    ...cacheMemoryRows(profile.modelPath, configured.flags, ctxSize),
+  ])));
   const cacheTypeK = await prompt.choice("K cache precision", CACHE_CHOICES, configured.flags.cacheTypeK);
+  configured = applyRuntimeFlagOverrides(configured, { cacheTypeK });
+
+  // ── V cache precision ──────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("V cache precision", renderRows([
+    ["What it is", "KV cache stores attention 'values' — token representations from previous layers"],
+    ["Tradeoff", "Same as K cache. Some models are more sensitive to V precision than K"],
+    ...cacheMemoryRows(profile.modelPath, configured.flags, ctxSize),
+  ])));
   const cacheTypeV = await prompt.choice("V cache precision", CACHE_CHOICES, configured.flags.cacheTypeV);
-  configured = applyRuntimeFlagOverrides(configured, { ctxSize, cacheTypeK, cacheTypeV });
+  configured = applyRuntimeFlagOverrides(configured, { cacheTypeV });
+
+  // ── Memory estimate (with chosen context + cache) ──────────────────────
+  console.log("");
+  console.log(renderMemoryEstimate(configured));
+
+  // ── Temperature ────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Temperature", renderRows([
+    ["What it does", "Controls randomness in token selection"],
+    ["Range", "0.0 – 2.0"],
+    ["0.0", "Deterministic — always picks most likely token"],
+    ["0.6", "Balanced — default for most models"],
+    ["1.0+", "Creative — more random, may hallucinate"],
+    ["Guidance", "0–0.3: coding/factual · 0.4–0.8: chat · 0.9+: creative writing"],
+  ])));
+  const temperature = await prompt.number("Temperature", configured.flags.temperature, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { temperature });
+
+  // ── Top-p ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Top-p (nucleus sampling)", renderRows([
+    ["What it does", "Only considers tokens in the top p fraction of probability mass"],
+    ["Range", "0.0 – 1.0 (1.0 = consider all tokens)"],
+    ["Guidance", "0.9–0.95: good default · Lower = more focused · Higher = more diverse"],
+  ])));
+  const topP = await prompt.number("Top-p", configured.flags.topP, 0, 1, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { topP });
+
+  // ── Top-k ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Top-k", renderRows([
+    ["What it does", "Limits token selection to top K most likely tokens at each step"],
+    ["Range", "0 – 1000 (0 = disabled, uses top-p instead)"],
+    ["Guidance", "20: general chat · 40–64: thinking/reasoning · 0: rely on top-p"],
+  ])));
+  const topK = await prompt.number("Top-k", configured.flags.topK, 0, 1000);
+  configured = applyRuntimeFlagOverrides(configured, { topK });
+
+  // ── Min-p ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Min-p", renderRows([
+    ["What it does", "Excludes tokens with probability below this threshold"],
+    ["Range", "0.0 – 1.0 (0 = disabled)"],
+    ["Guidance", "0: off (default) · 0.05–0.1: reduces hallucination while keeping creativity"],
+  ])));
+  const minP = await prompt.number("Min-p", configured.flags.minP, 0, 1, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { minP });
+
+  // ── Presence penalty ───────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Presence penalty", renderRows([
+    ["What it does", "Discourages repeated tokens — each used token gets a fixed logit penalty"],
+    ["Range", "0.0 – 2.0 (0 = off)"],
+    ["Guidance", "0: thinking/reasoning · 1.0–1.5: general chat · Too high = incoherent"],
+  ])));
+  const presencePenalty = await prompt.number("Presence penalty", configured.flags.presencePenalty, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { presencePenalty });
+
+  // ── Repeat penalty ─────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Repeat penalty", renderRows([
+    ["What it does", "Multiplies probability of repeated tokens (multiplicative, vs presence's additive)"],
+    ["Range", "0.0 – 2.0 (1.0 = no effect)"],
+    ["Guidance", "1.0–1.1: most use cases · Higher = aggressive anti-repeat · Can break code patterns"],
+  ])));
+  const repeatPenalty = await prompt.number("Repeat penalty", configured.flags.repeatPenalty, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { repeatPenalty });
+
+  // ── Batch size ─────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Batch size", renderRows([
+    ["What it does", "Tokens processed in parallel during prompt processing (before generation)"],
+    ["Range", "1 – 4096"],
+    ["Guidance", "512: good default · 2048+: faster for long prompts · Lower if memory tight"],
+  ])));
+  const batchSize = await prompt.number("Batch size", configured.flags.batchSize, 1, 4096);
+  configured = applyRuntimeFlagOverrides(configured, { batchSize });
+
+  // ── Parallel slots ─────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Parallel slots", renderRows([
+    ["What it does", "Number of concurrent request slots (each handles an independent conversation)"],
+    ["Range", "1 – 10"],
+    ["Memory", "KV cache is multiplied by this number"],
+    ["Guidance", "1: single-user local · 2+: multiple clients connecting simultaneously"],
+  ])));
+  const parallel = await prompt.number("Parallel slots", configured.flags.parallel, 1, 10);
+  configured = applyRuntimeFlagOverrides(configured, { parallel });
+
+  // ── Flash attention ────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Flash attention", renderRows([
+    ["What it does", "Memory-efficient attention algorithm — faster and less RAM than standard"],
+    ["Guidance", "Always on for modern hardware · Turn off only for old GPU driver compat issues"],
+  ])));
+  const flashAttn = await prompt.yesNo("Enable flash attention?", true);
+  configured = applyRuntimeFlagOverrides(configured, { flashAttention: flashAttn ? "on" : "off" });
+
+  // ── Jinja templates ────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Jinja chat templates", renderRows([
+    ["What it does", "Enables Jinja2 template rendering for proper chat formatting"],
+    ["Guidance", "Always on for modern models · Turn off only for very old models without chat templates"],
+  ])));
+  const jinja = await prompt.yesNo("Enable Jinja templates?", true);
+  configured = applyRuntimeFlagOverrides(configured, { jinja });
 
+  // ── Final summary ──────────────────────────────────────────────────────
   console.log("");
-  console.log(renderSection("Defaults", renderRows([
+  console.log(renderSection("Configuration summary", renderRows([
+    ["Model", pc.bold(configured.label)],
     ["Backend", configured.backend],
     ["Endpoint", configured.baseUrl],
-    ["Temperature", configured.flags.temperature],
-    ["Top-p", configured.flags.topP],
-    ["Top-k", configured.flags.topK],
-    ["Min-p", configured.flags.minP],
-    ["Presence penalty", configured.flags.presencePenalty],
-    ["Repeat penalty", configured.flags.repeatPenalty],
+    ["Context", `${configured.flags.ctxSize.toLocaleString()} tokens`],
+    ["KV cache", `${configured.flags.cacheTypeK}/${configured.flags.cacheTypeV}`],
+    ["Temperature", String(configured.flags.temperature)],
+    ["Top-p", String(configured.flags.topP)],
+    ["Top-k", String(configured.flags.topK)],
+    ["Min-p", String(configured.flags.minP)],
+    ["Presence penalty", String(configured.flags.presencePenalty)],
+    ["Repeat penalty", String(configured.flags.repeatPenalty)],
+    ["Batch size", String(configured.flags.batchSize)],
+    ["Parallel", String(configured.flags.parallel)],
+    ["Flash attention", configured.flags.flashAttention],
+    ["Jinja", configured.flags.jinja ? "on" : "off"],
+    ...(configured.capabilities?.mtp ? [["MTP", "enabled"]] : []),
+    ...(configured.capabilities?.vision ? [["Vision", "enabled"]] : []),
+    ...(configured.capabilities?.thinking ? [["Thinking", "enabled"]] : []),
   ])));
 
-  console.log("\n" + renderMemoryEstimate(configured));
+  console.log("");
+  console.log(renderMemoryEstimate(configured));
   if (!(await prompt.yesNo("Save profile with these settings?", true))) return null;
   return configured;
 }
@@ -240,10 +398,12 @@ function applyProfileFlags(profile, flags) {
 
 function renderMemoryEstimate(profile) {
   try {
-    const est = estimateMemory(profile.modelPath, profile.mmprojPath, null, profile.flags);
+    const est = estimateMemory(profile.modelPath, profile.mmprojPath, profile.drafterPath, profile.flags);
     return renderSection("Memory estimate", renderRows([
       ["Estimated total", pc.bold(`~${formatBytes(est.totalBytes)}`)],
       ["Model", formatBytes(est.modelBytes)],
+      ...(est.mmprojBytes ? [["Vision projector", formatBytes(est.mmprojBytes)]] : []),
+      ...(est.draftBytes ? [["Drafter (MTP)", formatBytes(est.draftBytes)]] : []),
       ["KV cache", est.kvBytes ? `~${formatBytes(est.kvBytes)} (${profile.flags.ctxSize.toLocaleString()} ctx, ${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV})` : "unknown"],
       ...(est.note ? [["Note", pc.yellow(est.note)]] : []),
     ]));
@@ -269,8 +429,5 @@ async function runtimeSupportsGemma4Unified() {
   }
 }
 
-function samplingSummary(flags) {
-  return `temp ${flags.temperature}, top-p ${flags.topP}, top-k ${flags.topK}`;
-}
 
 

package/src/ui.mjs

@@ -95,12 +95,12 @@ export function renderCard(title, body, options = {}) {
   }
 
   const topTitle = title ? `╭${pc.reset(titleStr)}` : "╭";
-  const topFill = "─".repeat(Math.max(0, width + 2 - visibleLen(titleStr)));
+  const topFill = "─".repeat(Math.max(0, width - visibleLen(titleStr)));
   const top = `${topTitle}${topFill}╮`;
 
   const middle = lines.map((line) => `│ ${padVisible(line, contentWidth)} │`);
 
-  const bottom = `╰${"─".repeat(width + 2)}╯`;
+  const bottom = `╰${"─".repeat(width)}╯`;
 
   return [top, ...middle, bottom].map((l) => borderColor(l)).join("\n");
 }
@@ -180,9 +180,8 @@ async function runPrompt(fn, config) {
 
 // ── Interactive prompt factory ──────────────────────────────────────────────
 
-export function startInteractive(title = "offgrid-ai") {
+export function startInteractive() {
   if (process.stdin.isTTY) console.clear();
-  console.log(pc.magenta(`◆ ${title}`));
 }
 
 export function createPrompt() {
@@ -195,10 +194,13 @@ export function createPrompt() {
       return value?.trim() || String(defaultValue ?? "");
     },
 
-    async number(label, defaultValue, min, max) {
+    async number(label, defaultValue, min, max, { float = false } = {}) {
       const value = await runPrompt(number, {
         message: label,
         default: defaultValue,
+        min,
+        max,
+        step: float ? 'any' : 1,
         validate(input) {
           if (!Number.isFinite(input) || input < min || input > max) {
             return `Enter a number from ${min} to ${max}.`;
@@ -235,12 +237,10 @@ export function createPrompt() {
 
 export async function modelSelect(label, groups, { defaultKey, pageSize = 20 } = {}) {
   const choices = [];
-  // Separator below the prompt message
-  choices.push(new Separator(pc.dim("  ────────────────────────────────────────────────────────────")));
   for (let i = 0; i < groups.length; i++) {
     const group = groups[i];
     // Add blank line before each group (except the first)
-    if (i > 0) choices.push(new Separator(""));
+    if (i > 0) choices.push(new Separator(" "));
     if (group.separator) {
       choices.push(new Separator(group.separator));
     }

package/src/benchmark/finalize.mjs

@@ -1,169 +0,0 @@
-// ── Benchmark finalization (metadata + summary rendering) ───────────────────
-// unloadModelFromServer has been moved to src/process.mjs (it's the managed-server
-// counterpart to stopProfile, used by both the benchmark flow and the Pi chat flow).
-
-import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { pc, renderRows, renderSection } from "../ui.mjs";
-
-export async function finalizeBenchmarkRun(runDirectory, runResult, speedMetrics, speedMetricsError = null) {
-  const metadataPath = join(runDirectory, "metadata.json");
-  const metadata = JSON.parse(await readFile(metadataPath, "utf8"));
-  const now = new Date();
-  const timestamp = now.toISOString();
-
-  const kind = metadata.kind ?? "visual";
-  const isDs = kind === "data-science";
-  const requiredFile = isDs ? "analysis.ipynb" : "index.html";
-  const requiredPath = join(runDirectory, requiredFile);
-
-  const outputFiles = [];
-  for (const candidate of [requiredFile, isDs ? "summary.json" : "preview.png", isDs ? "chart-distribution.png" : "preview.webm", "preview.mp4"]) {
-    if (existsSync(join(runDirectory, candidate))) {
-      outputFiles.push(candidate);
-    }
-  }
-
-  const success = existsSync(requiredPath) && (await readFile(requiredPath, "utf8")).trim().length > 0;
-  const hasTurns = runResult.agentTurns > 0;
-
-  let failureReason = null;
-  if (runResult.error) {
-    failureReason = typeof runResult.error === "string" ? runResult.error : (runResult.error.message ?? "Unknown error");
-  } else if (!hasTurns) {
-    failureReason = "The model did not produce any response turns.";
-  } else if (!success) {
-    if (runResult.toolCalls === 0) {
-      failureReason = `The model finished without writing the required output file (${requiredFile}). It may have returned the response as chat text instead of using the write tool.`;
-    } else {
-      failureReason = `The required output file (${requiredFile}) was missing or empty after the run.`;
-    }
-  }
-
-  const failed = failureReason !== null;
-
-  metadata.status = failed ? "failed" : "completed";
-  metadata.updatedAt = timestamp;
-  if (failed) {
-    metadata.failedAt = timestamp;
-  } else {
-    metadata.completedAt = timestamp;
-  }
-
-  const totalTokens = runResult.promptTokens + runResult.completionTokens;
-
-  metadata.runner.tokenMetrics = {
-    reported: hasTurns,
-    promptTokens: runResult.promptTokens,
-    completionTokens: runResult.completionTokens,
-    totalTokens,
-  };
-
-  metadata.runner.speedMetrics = speedMetrics;
-  metadata.runner.metricSource = speedMetrics?.metricSource ?? null;
-  metadata.runner.speedMetricsError = speedMetricsError ?? null;
-
-  metadata.results = {
-    wallClockMs: runResult.wallClockMs,
-    agentTurns: runResult.agentTurns,
-    toolCalls: runResult.toolCalls,
-    toolResults: runResult.toolResults,
-    success,
-    outputFiles,
-    perTurn: runResult.perTurn,
-  };
-
-  if (failureReason) {
-    metadata.error = { message: failureReason, ...(typeof runResult.error === "object" && runResult.error?.stack ? { stack: runResult.error.stack } : {}) };
-  } else if (runResult.error) {
-    metadata.error = typeof runResult.error === "string"
-      ? { message: runResult.error }
-      : { message: runResult.error.message ?? "Unknown error", ...(runResult.error.stack ? { stack: runResult.error.stack } : {}) };
-  }
-
-  await writeFile(metadataPath, JSON.stringify(metadata, null, 2) + "\n", "utf8");
-  return metadata;
-}
-
-function formatMetric(value, formatter) {
-  if (value === null || value === undefined || !Number.isFinite(value)) return pc.dim("—");
-  return formatter(value);
-}
-
-function formatMs(ms) {
-  return formatMetric(ms, (n) => (n < 1000 ? `${Math.round(n)} ms` : `${(n / 1000).toFixed(1)} s`));
-}
-
-function formatNumber(n) {
-  return formatMetric(n, (v) => v.toLocaleString());
-}
-
-function formatTokPerSec(n) {
-  return formatMetric(n, (v) => `${v.toFixed(1)} tok/s`);
-}
-
-function formatPercent(n) {
-  return formatMetric(n, (v) => `${(v * 100).toFixed(0)} %`);
-}
-
-export function renderBenchmarkSummary(metadata) {
-  const { status, results, runner, error } = metadata;
-
-  const agentRows = [
-    ["Status", status === "completed" ? pc.green("completed") : pc.red(status ?? "failed")],
-    ["Duration", formatMs(results?.wallClockMs)],
-    ["Agent turns", formatNumber(results?.agentTurns)],
-    ["Input tokens", formatNumber(runner?.tokenMetrics?.promptTokens)],
-    ["Output tokens", formatNumber(runner?.tokenMetrics?.completionTokens)],
-    ["Total tokens", formatNumber(runner?.tokenMetrics?.totalTokens)],
-    ["Tool calls", formatNumber(results?.toolCalls)],
-    ["Tool results", formatNumber(results?.toolResults)],
-    ["Output files", (results?.outputFiles?.length ?? 0) > 0 ? results.outputFiles.join(", ") : pc.dim("—")],
-  ];
-
-  console.log("");
-  console.log(renderSection("Benchmark Result", renderRows(agentRows)));
-
-  if (status === "completed" && runner?.speedMetrics) {
-    const speed = runner.speedMetrics;
-    const speedRows = [
-      ["Prefill tok/s", formatTokPerSec(speed.prefillTokensPerSecond)],
-      ["Generation tok/s", formatTokPerSec(speed.generationTokensPerSecond)],
-      ["TTFT", formatMs(speed.ttftMs)],
-      ["Speculative decode", formatPercent(speed.speculativeDecodeAcceptance)],
-      ["KV cache tokens", formatNumber(speed.kvCacheTokens)],
-      ["Model load time", formatMs(speed.modelLoadMs)],
-      ["Metric source", speed.metricSource ?? pc.dim("—")],
-    ];
-    console.log(renderSection("Speed Metrics", renderRows(speedRows)));
-  } else if (error) {
-    const wrappedError = wrapText(error.message ?? "Unknown error");
-    console.log(renderSection("Error", pc.red(wrappedError)));
-    if (error.message?.includes("write tool") || error.message?.includes("required output file")) {
-      const tip = wrapText("Tip: This usually means the model returned the answer as chat text instead of writing the file. Try a model with stronger tool-use support, or run the prompt manually.", 64);
-      console.log(pc.dim("\n" + tip));
-    }
-  }
-
-  if (status === "completed" && !runner?.speedMetrics && runner?.speedMetricsError) {
-    console.log(pc.dim(`\nSpeed metrics unavailable: ${runner.speedMetricsError}`));
-  }
-}
-
-function wrapText(text, width = 64) {
-  if (!text) return "";
-  const words = text.split(/\s+/);
-  const lines = [];
-  let current = "";
-  for (const word of words) {
-    if ((current + " " + word).trim().length > width) {
-      if (current) lines.push(current.trim());
-      current = word;
-    } else {
-      current = current ? `${current} ${word}` : word;
-    }
-  }
-  if (current) lines.push(current.trim());
-  return lines.join("\n");
-}