offgrid-ai 0.12.2 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.12.2",
+  "version": "0.14.0",
   "description": "Privacy-first CLI for running local LLMs — discover, configure, run, benchmark",
   "author": "Eeshan Srivastava (https://eeshans.com)",
   "type": "module",
@@ -43,6 +43,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.4.0",
+    "@earendil-works/pi-agent-core": "^0.80.3",
+    "@earendil-works/pi-ai": "^0.80.3",
+    "@earendil-works/pi-coding-agent": "^0.80.3",
     "picocolors": "^1.1.0"
   },
   "keywords": [

package/src/autodetect.mjs

@@ -50,7 +50,7 @@ export function detectCapabilities(modelPath, mmprojPath) {
 
 // ── Compute llama-server flags from capabilities ───────────────────────────
 
-export function computeFlags(capabilities, modelPath, mmprojPath, draftModelPath) {
+export function computeFlags(capabilities, modelPath, mmprojPath, draftModelPath, flagOverrides = {}) {
   const { thinking, mtp, quant } = capabilities;
   const isLowMem = quant && /[Qq]4[_0]/i.test(quant);
 
@@ -69,6 +69,7 @@ export function computeFlags(capabilities, modelPath, mmprojPath, draftModelPath
     repeatPenalty: thinking ? 1.1 : 1.0,
     parallel: 1,
     batchSize: 512,
+    ...flagOverrides,
   };
 
   // Thinking mode

package/src/benchmark/flow.mjs

@@ -3,14 +3,13 @@
 import { join } from "node:path";
 import { ensureDirs } from "../config.mjs";
 import { backendFor } from "../backends.mjs";
-import { hasPi, hasPiModel, syncPiConfig } from "../harness-pi.mjs";
 import { serverReady, startServer, waitForReady, stopProfile, modelAvailableOnServer, unloadModelFromServer } from "../process.mjs";
 import { loadProfiles } from "../profiles.mjs";
 import { pc, createPrompt } from "../ui.mjs";
 import { linkBenchmarkRepo } from "./repo.mjs";
 import { loadBenchmarks } from "./shared.mjs";
 import { prepareBenchmarkRun } from "./prepare.mjs";
-import { runBenchmarkInPi } from "./pi-runner.mjs";
+import { runBenchmarkInPi } from "./sdk-runner.mjs";
 import { queryServerMetrics } from "./metrics.mjs";
 import { finalizeBenchmarkRun, renderBenchmarkSummary } from "./finalize.mjs";
 
@@ -63,7 +62,7 @@ export async function runPreparedBenchmark(profile, runDirectory, options = {})
   }
   let serverStarted = false;
   let benchmarkStarted = false;
-  let metadata = null;
+  let metadata;
 
   const onSigint = () => {
     controller.abort();
@@ -71,18 +70,9 @@ export async function runPreparedBenchmark(profile, runDirectory, options = {})
   process.on("SIGINT", onSigint);
 
   try {
-    if (!(await hasPi())) {
-      console.log(pc.yellow("\nPi is not installed. Run prepared for manual execution."));
-      return metadata;
-    }
-
     const serverState = await ensureServerForBenchmark(profile);
     serverStarted = serverState.started;
 
-    if (!(await hasPiModel(profile))) {
-      await syncPiConfig(profile);
-    }
-
     benchmarkStarted = true;
     const runResult = await runBenchmarkInPi(profile, runDirectory, { signal: controller.signal });
 
@@ -168,7 +158,7 @@ export async function benchmarkForProfile(profile) {
     const modelSource = benchmarkModelSource(profile);
     const backendLabel = backendFor(profile.backend).label;
 
-    const canRun = (await hasPi()) && modelSource !== "cloud";
+    const canRun = modelSource !== "cloud";
     const action = await chooseBenchmarkAction(prompt, canRun);
 
     const runDirectory = await prepareBenchmarkRun({ repoPath, benchmark: selectedBenchmark, kind, modelId, modelSource, backendLabel, profile, showNextSteps: action === "prepare" });
@@ -238,7 +228,7 @@ export async function benchmarkFlow() {
       modelSource = "cloud";
     }
 
-    const canRun = (await hasPi()) && modelSource !== "cloud" && profile != null;
+    const canRun = modelSource !== "cloud" && profile != null;
     const action = await chooseBenchmarkAction(prompt, canRun);
 
     const runDirectory = await prepareBenchmarkRun({ repoPath, benchmark: selectedBenchmark, kind, modelId, modelSource, backendLabel, profile, showNextSteps: action === "prepare" });

package/src/benchmark/prepare.mjs

@@ -46,9 +46,6 @@ export async function prepareBenchmarkRun({ repoPath, benchmark, kind, modelId,
   const baseAssets = {
     metadata: "metadata.json",
     prompt: "prompt.md",
-    rawResponse: "response.raw.txt",
-    stream: "stream.ndjson",
-    stderr: "stderr.log",
   };
   const metadata = {
     schemaVersion: 1,

package/src/benchmark/sdk-runner.mjs

@@ -0,0 +1,380 @@
+// ── Run benchmark via Pi SDK (no subprocess, no NDJSON parsing) ────────────────
+
+import { readFile } from "node:fs/promises";
+import { join, relative, basename } from "node:path";
+import { Agent } from "@earendil-works/pi-agent-core";
+import { streamSimple } from "@earendil-works/pi-ai/compat";
+import { createCodingTools } from "@earendil-works/pi-coding-agent";
+import { pc } from "../ui.mjs";
+import { piApiModelId } from "../harness-pi.mjs";
+
+const C = {
+  thinking: pc.magenta,
+  text: pc.green,
+  tool: pc.yellow,
+  success: pc.green,
+  warning: pc.yellow,
+  error: pc.red,
+  info: pc.cyan,
+  dim: pc.dim,
+};
+
+export async function runBenchmarkInPi(profile, runDirectory, { signal } = {}) {
+  const model = buildModel(profile);
+  const tools = createCodingTools(runDirectory);
+  const systemPrompt = buildSystemPrompt(runDirectory);
+  const promptText = await readFile(join(runDirectory, "prompt.md"), "utf8");
+
+  const runResult = {
+    model: `${profile.providerId}/${piApiModelId(profile)}`,
+    exitCode: 0,
+    wallClockMs: null,
+    agentTurns: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    toolCalls: 0,
+    toolResults: 0,
+    perTurn: [],
+    rawResponseLines: [],
+    error: null,
+  };
+
+  const runStartMs = Date.now();
+  let currentTurnStartMs = null;
+  let lastTurnEndMs = null;
+  let turnToolCalls = 0;
+  let responseBuffer = "";
+  const verbose = Boolean(process.env.OFFGRID_BENCHMARK_VERBOSE);
+  const toolArgsByCallId = new Map();
+
+  // ── Status line state ────────────────────────────────────────────────────
+  let statusBytes = 0;
+  let streamedText = false;
+  let execTimer = null;
+  let execStartedAt = null;
+
+  function clearStatusLine() {
+    if (process.stdout.isTTY) process.stdout.write("\r\x1b[K");
+  }
+
+  function printStatusLine(text) {
+    if (process.stdout.isTTY) process.stdout.write(`\r\x1b[K${text}`);
+  }
+
+  function stopExecTimer() {
+    if (execTimer) { clearInterval(execTimer); execTimer = null; }
+    clearStatusLine();
+  }
+
+  function startExecTimer(toolName) {
+    stopExecTimer();
+    execStartedAt = Date.now();
+    if (!process.stdout.isTTY) return;
+    const update = () => {
+      const elapsed = Math.floor((Date.now() - execStartedAt) / 1000);
+      printStatusLine(C.dim(`running ${toolName}… ${elapsed}s`));
+    };
+    update();
+    execTimer = setInterval(update, 1000);
+  }
+
+  const agent = new Agent({
+    initialState: {
+      systemPrompt,
+      model,
+      thinkingLevel: profile.reasoning ? "low" : "off",
+      tools,
+    },
+    streamFn: async (mdl, ctx, opts) =>
+      streamSimple(mdl, ctx, { ...opts, apiKey: "none" }),
+  });
+
+  // ── Event handler: render + collect metrics ──────────────────────────────
+
+  agent.subscribe((event) => {
+    try {
+      handleEvent(event);
+    } catch (err) {
+      console.error(C.error(`[renderer error] ${err.message}`));
+    }
+  });
+
+  function handleEvent(event) {
+    switch (event.type) {
+      case "turn_start": {
+        stopExecTimer();
+        runResult.agentTurns += 1;
+        currentTurnStartMs = lastTurnEndMs ?? runStartMs;
+        turnToolCalls = 0;
+        console.log("");
+        console.log(C.info(`Turn ${runResult.agentTurns}`));
+        break;
+      }
+
+      case "message_update": {
+        const evt = event.assistantMessageEvent;
+        if (!evt) break;
+        const sub = String(evt.type ?? "").replace(/_/gu, "");
+        if (sub === "thinkingstart") {
+          statusBytes = 0;
+        } else if (sub === "thinkingdelta") {
+          statusBytes += Buffer.byteLength(evt.delta || "", "utf8");
+          const tokens = Math.max(1, Math.ceil(statusBytes / 4));
+          printStatusLine(C.dim(`thinking… ${formatBytes(statusBytes)} (~${formatTokens(tokens)} tokens)`));
+          if (verbose) process.stdout.write(C.thinking(evt.delta || ""));
+        } else if (sub === "textstart") {
+          clearStatusLine();
+          statusBytes = 0;
+        } else if (sub === "textdelta") {
+          process.stdout.write(evt.delta || "");
+          responseBuffer += evt.delta || "";
+          streamedText = true;
+        } else if (sub === "toolcallstart") {
+          clearStatusLine();
+        }
+        break;
+      }
+
+      case "message_end": {
+        if (streamedText) {
+          console.log("");
+          streamedText = false;
+        }
+        if (event.message?.role === "assistant") {
+          for (const item of event.message.content ?? []) {
+            if (item.type === "toolCall") {
+              runResult.toolCalls += 1;
+              turnToolCalls += 1;
+              responseBuffer += `\n[toolCall] ${item.name}\n`;
+            }
+          }
+          if (responseBuffer) {
+            runResult.rawResponseLines.push(responseBuffer);
+            responseBuffer = "";
+          }
+        }
+        break;
+      }
+
+      case "tool_execution_start": {
+        clearStatusLine();
+        toolArgsByCallId.set(event.toolCallId, event.args);
+        console.log(C.tool(formatToolStart(event.toolName, event.args, runDirectory)));
+        startExecTimer(event.toolName);
+        break;
+      }
+
+      case "tool_execution_end": {
+        stopExecTimer();
+        const { toolName, result, isError, toolCallId } = event;
+        const args = toolArgsByCallId.get(toolCallId) ?? {};
+        const marker = isError ? C.error("✗") : C.success("✓");
+        console.log(`${marker} ${toolSummary(toolName, result, isError, args, runDirectory)}`);
+        runResult.toolResults += 1;
+        break;
+      }
+
+      case "turn_end": {
+        stopExecTimer();
+        clearStatusLine();
+        const msg = event.message;
+        const isFailure = msg?.role === "assistant" && (msg.stopReason === "error" || msg.stopReason === "aborted");
+        const usage = !isFailure ? msg?.usage : null;
+        if (usage) {
+          runResult.promptTokens += usage.input ?? 0;
+          runResult.completionTokens += usage.output ?? 0;
+          runResult.cacheRead += usage.cacheRead ?? 0;
+          runResult.cacheWrite += usage.cacheWrite ?? 0;
+        }
+        const turnEndMs = Date.now();
+        const wallClockMs = currentTurnStartMs ? turnEndMs - currentTurnStartMs : null;
+        runResult.perTurn.push({
+          turn: runResult.agentTurns,
+          inputTokens: usage?.input ?? 0,
+          outputTokens: usage?.output ?? 0,
+          cacheRead: usage?.cacheRead ?? 0,
+          cacheWrite: usage?.cacheWrite ?? 0,
+          wallClockMs,
+          toolCalls: turnToolCalls,
+        });
+        lastTurnEndMs = turnEndMs;
+        const tokStr = usage ? ` · ${formatTokens(usage.output ?? 0)} tokens` : "";
+        console.log(C.success(`✓ turn ${runResult.agentTurns}${tokStr}`));
+        break;
+      }
+
+      case "agent_end": {
+        if (responseBuffer) {
+          runResult.rawResponseLines.push(responseBuffer);
+          responseBuffer = "";
+        }
+        break;
+      }
+    }
+  }
+
+  // ── Wire abort signal ────────────────────────────────────────────────────
+
+  let cancelled = false;
+  const abortListener = () => {
+    cancelled = true;
+    agent.abort();
+  };
+  if (signal) signal.addEventListener("abort", abortListener, { once: true });
+
+  // ── Run ───────────────────────────────────────────────────────────────────
+
+  try {
+    console.log(C.info("Pi benchmark started"));
+    console.log(C.dim(`  Model    ${model.provider}/${model.id}`));
+    await agent.prompt(promptText);
+  } catch (err) {
+    if (!cancelled) {
+      runResult.error = { message: err.message };
+    }
+  } finally {
+    if (signal) signal.removeEventListener("abort", abortListener);
+  }
+
+  if (cancelled) {
+    runResult.error = { message: "Cancelled by user" };
+  }
+
+  if (!runResult.error && agent.state.errorMessage) {
+    runResult.error = { message: agent.state.errorMessage };
+  }
+
+  runResult.wallClockMs = Date.now() - runStartMs;
+  runResult.totalTokens = runResult.promptTokens + runResult.completionTokens;
+
+  console.log(C.info("Pi benchmark finished"));
+  return runResult;
+}
+
+// ── Model construction ──────────────────────────────────────────────────────
+
+function buildModel(profile) {
+  const text = [profile.id, profile.label, profile.modelAlias, profile.modelPath, profile.omlxModel]
+    .filter(Boolean).join(" ").toLowerCase();
+  const reasoning = profile.reasoning !== undefined
+    ? Boolean(profile.reasoning)
+    : /qwen|gemma-4|gemma 4/i.test(text);
+  const hasCompat = profile.compat
+    ? profile.compat
+    : /qwen|gemma-4|gemma 4/i.test(text)
+      ? { thinkingFormat: "qwen-chat-template" }
+      : null;
+
+  return {
+    id: piApiModelId(profile),
+    name: profile.label,
+    api: "openai-completions",
+    provider: profile.providerId,
+    baseUrl: profile.baseUrl,
+    reasoning,
+    input: profile.mmprojPath || profile.capabilities?.vision ? ["text", "image"] : ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: profile.flags?.ctxSize ?? 32768,
+    maxTokens: 16384,
+    compat: {
+      supportsDeveloperRole: false,
+      supportsReasoningEffort: false,
+      maxTokensField: "max_tokens",
+      ...(hasCompat ?? {}),
+    },
+  };
+}
+
+// ── System prompt ───────────────────────────────────────────────────────────
+
+function buildSystemPrompt(cwd) {
+  const now = new Date();
+  const date = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  return `You are an expert coding assistant. You help users by reading files, executing commands, editing code, and writing new files.
+
+Available tools:
+- read: Read file contents (supports text and images)
+- bash: Execute shell commands
+- edit: Apply targeted text replacements to files
+- write: Write content to files (creates or overwrites)
+
+Guidelines:
+- Be concise in your responses
+- Show file paths clearly when working with files
+- Use the write tool to create files — do not return file contents as chat text
+- Use bash to run commands and verify your work
+
+Current date: ${date}
+Current working directory: ${cwd.replace(/\\/gu, "/")}`;
+}
+
+// ── Rendering helpers ───────────────────────────────────────────────────────
+
+function formatToolStart(toolName, args, cwd) {
+  if (toolName === "read") return `→ read ${relPath(args.path, cwd)}`;
+  if (toolName === "write") {
+    const size = args.content ? ` · ${formatBytes(Buffer.byteLength(String(args.content), "utf8"))}` : "";
+    return `→ write ${relPath(args.path, cwd)}${size}`;
+  }
+  if (toolName === "edit") {
+    const count = Array.isArray(args.edits) ? args.edits.length : 0;
+    return `→ edit ${relPath(args.path, cwd)}${count > 0 ? ` · ${count} replacement${count === 1 ? "" : "s"}` : ""}`;
+  }
+  if (toolName === "bash") return `→ run ${truncateOneLine(args.command ?? "")}`;
+  return `→ ${toolName}`;
+}
+
+function toolSummary(toolName, result, isError, args, cwd) {
+  const text = toolResultText(result);
+  if (isError) return `${toolName} failed · ${firstLine(text)}`;
+  if (toolName === "write") {
+    const m = String(text).match(/Successfully wrote\s+([0-9,]+)\s+bytes/iu);
+    const size = m ? ` · ${formatBytes(Number(m[1].replace(/,/gu, "")))}` : "";
+    return `wrote ${relPath(args.path, cwd)}${size}`;
+  }
+  if (toolName === "read") return `read ${relPath(args.path, cwd)}${text ? ` · ${formatBytes(Buffer.byteLength(text, "utf8"))}` : ""}`;
+  if (toolName === "edit") return `edited ${relPath(args.path, cwd)}`;
+  if (toolName === "bash") return firstLine(text) || "command completed";
+  return `${toolName}${text ? ` · ${firstLine(text)}` : ""}`;
+}
+
+function toolResultText(result) {
+  const content = result?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c?.text ?? "").filter(Boolean).join("\n");
+}
+
+function firstLine(text) {
+  return String(text ?? "").split(/\r?\n/u).map((s) => s.trim()).find(Boolean) ?? "no details";
+}
+
+function relPath(path, cwd) {
+  if (!path) return "unknown";
+  const r = relative(cwd, String(path));
+  if (r && !r.startsWith("..") && r !== ".") return r;
+  return basename(String(path)) || String(path);
+}
+
+function truncateOneLine(value, max = 80) {
+  const text = String(value ?? "").replace(/\s+/gu, " ").trim();
+  return text.length > max ? `${text.slice(0, Math.max(1, max - 1))}…` : text;
+}
+
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes)) return "unknown";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = bytes;
+  let unit = 0;
+  while (size >= 1024 && unit < units.length - 1) { size /= 1024; unit += 1; }
+  return `${size.toFixed(unit === 0 ? 0 : 2)} ${units[unit]}`;
+}
+
+function formatTokens(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${Math.round(n / 1_000)}k`;
+  return String(Math.round(n));
+}

package/src/benchmark.mjs

@@ -4,7 +4,7 @@
 export { slugModelId, createRunId, buildToolPrompt, loadBenchmarks, piModelString } from "./benchmark/shared.mjs";
 export { findBenchmarkRepo, linkBenchmarkRepo } from "./benchmark/repo.mjs";
 export { prepareBenchmarkRun } from "./benchmark/prepare.mjs";
-export { runBenchmarkInPi } from "./benchmark/pi-runner.mjs";
+export { runBenchmarkInPi } from "./benchmark/sdk-runner.mjs";
 export { queryServerMetrics } from "./benchmark/metrics.mjs";
 // unloadModelFromServer now lives in src/process.mjs (managed-server counterpart to stopProfile).
 export { unloadModelFromServer } from "./process.mjs";

package/src/model-presenters.mjs

@@ -1,9 +1,8 @@
 import { existsSync, statSync } from "node:fs";
-import { basename, dirname } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { backendFor } from "./backends.mjs";
-import { readCommandArgv } from "./profiles.mjs";
-import { isProfileRunning } from "./process.mjs";
-import { buildPrettyCommand } from "./command.mjs";
+import { computeServerCommand, buildStartScript, isProfileRunning } from "./process.mjs";
+import { profileDir } from "./profiles.mjs";
 import { pc, formatBytes, renderRows, renderSection } from "./ui.mjs";
 import { capabilitySummary, ggufDetailParts, isProfileFileMissing, profileDetailParts } from "./model-summary.mjs";
 import { itemKey } from "./model-catalog.mjs";
@@ -260,9 +259,16 @@ export async function printProfileDetails(profile) {
 
   if (fileMissing) console.log("\n" + pc.red("⚠ This model's file is no longer on disk. Remove this setup or move the file back."));
 
-  if (!isManaged && profile.commandArgv) {
-    const commandArgv = await readCommandArgv(profile);
-    console.log("\n" + renderSection("llama-server command", pc.dim(buildPrettyCommand({ ...profile, commandArgv })), { columns: 120 }));
+  if (!isManaged) {
+    const command = await computeServerCommand(profile);
+    if (command) {
+      const script = buildStartScript(profile, command);
+      const scriptPath = join(profileDir(profile.id), "start.sh");
+      console.log("\n" + renderSection("Server command", renderRows([
+        ["Run manually", pc.cyan(`bash ${scriptPath}`)],
+        ["Command", pc.dim(script)],
+      ]), { columns: 120 }));
+    }
   }
 }
 

package/src/process.mjs

@@ -1,14 +1,85 @@
 import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { closeSync, openSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, writeFile, chmod } from "node:fs/promises";
 import { basename, join } from "node:path";
+import { quoteShell } from "./command.mjs";
 import { LOG_DIR } from "./config.mjs";
-import { writeState, readState, readCommandArgv } from "./profiles.mjs";
+import { writeState, readState, profileDir } from "./profiles.mjs";
 import { backendFor, backendBinaryFor } from "./backends.mjs";
 
 const execFileAsync = promisify(execFile);
 
+// ── Compute server command from profile config ─────────────────────────────
+// Single source of truth: derives the full command (binary + args + env) from
+// the profile's stored configuration.  Used for both launching and display so
+// they always match.  No stored commandArgv — the command is always fresh.
+
+export async function computeServerCommand(profile) {
+  const backend = backendFor(profile.backend);
+  if (backend.type === "managed-server") return null;
+
+  const binary = await backendBinaryFor(profile.backend);
+  if (!binary) throw new Error("Server binary not found. Run offgrid-ai interactively to install.");
+
+  let argv, extraEnv;
+
+  if (profile.backend === "mlx-vlm") {
+    const { computeMlxVlmFlags } = await import("./mlx-flags.mjs");
+    const result = computeMlxVlmFlags(profile.modelPath, {
+      port: profile.flags?.port,
+      ctxSize: profile.flags?.ctxSize,
+      thinkingEnabled: profile.capabilities?.thinking ?? true,
+    });
+    argv = result.args;
+    extraEnv = { APC_ENABLED: "1", MLX_VLM_MAX_TOKENS: "16384" };
+  } else {
+    // llama-cpp / llama-cpp-mtp
+    const { computeFlags } = await import("./autodetect.mjs");
+    const result = computeFlags(
+      profile.capabilities ?? {},
+      profile.modelPath,
+      profile.mmprojPath,
+      profile.drafterPath,
+      profile.flags ?? {},
+    );
+    argv = result.argv;
+    extraEnv = {};
+  }
+
+  return { binary, argv, extraEnv, backend };
+}
+
+/** Build a runnable start.sh script for the profile. */
+export function buildStartScript(profile, command) {
+  const { binary, argv, extraEnv } = command;
+  const backend = backendFor(profile.backend);
+  const lines = [
+    "#!/bin/bash",
+    `# Generated by offgrid-ai — do not edit`,
+    `# Profile: ${profile.label}`,
+    `# Backend: ${backend.label}`,
+  ];
+  for (const [key, value] of Object.entries(extraEnv)) {
+    lines.push(`export ${key}="${value}"`);
+  }
+  lines.push(""); // blank line before exec
+  // Format the exec command with backslash continuation
+  lines.push(`exec ${quoteShell(binary)} \\`);
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    const hasValue = arg.startsWith("--") && next && !next.startsWith("--");
+    if (hasValue) {
+      lines.push(`  ${arg} ${quoteShell(next)}${i + 2 < argv.length ? " \\" : ""}`);
+      i += 1;
+    } else {
+      lines.push(`  ${arg}${i + 1 < argv.length ? " \\" : ""}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
 // ── Start server ───────────────────────────────────────────────────────────
 
 export async function startServer(profile) {
@@ -20,23 +91,24 @@ export async function startServer(profile) {
 }
 
 async function startLocalServer(profile) {
-  const binary = await backendBinaryFor(profile.backend);
-  if (!binary) {
-    throw new Error("llama-server not found. Install the managed llama.cpp runtime by running offgrid-ai interactively.");
-  }
+  const command = await computeServerCommand(profile);
+  if (!command) throw new Error("No server command for this backend.");
+
+  const { binary, argv, extraEnv } = command;
 
   const timestamp = timestampForFile();
   const rawLogPath = join(LOG_DIR, `${profile.id}-${timestamp}.raw.log`);
   const friendlyLogPath = join(LOG_DIR, `${profile.id}-${timestamp}.friendly.log`);
-  const commandArgv = await readCommandArgv(profile);
 
-  await writeFile(rawLogPath, `[offgrid-ai] ${new Date().toISOString()}\n[binary] ${binary}\n[argv]\n${commandArgv.join(" ")}\n`, "utf8");
-  await writeFile(friendlyLogPath, `[launch] starting llama-server for ${profile.label}\n`, "utf8");
+  // Write start.sh so the user can run the model manually
+  const scriptPath = join(profileDir(profile.id), "start.sh");
+  await writeFile(scriptPath, buildStartScript(profile, command), "utf8");
+  await chmod(scriptPath, 0o755);
+
+  await writeFile(rawLogPath, `[offgrid-ai] ${new Date().toISOString()}\n[binary] ${binary}\n[argv]\n${argv.join(" ")}\n`, "utf8");
+  await writeFile(friendlyLogPath, `[launch] starting ${backendFor(profile.backend).label} for ${profile.label}\n`, "utf8");
 
-  // Build argv: binary + command.json args
-  const argv = [...commandArgv];
-  // mlx-vlm requires APC_ENABLED=1 (86x TTFT improvement; fixes Metal cache clearing).
-  const env = profile.backend === "mlx-vlm" ? { ...process.env, APC_ENABLED: "1" } : process.env;
+  const env = { ...process.env, ...extraEnv };
 
   const rawFd = openSync(rawLogPath, "a");
   let child;

package/src/profiles.mjs

@@ -69,14 +69,9 @@ export async function saveProfile(profile, options = {}) {
   };
   await writeJson(profileJsonPath(id), saved);
 
-  // Write JSON command file for llama-server backends
-  const backend = backendFor(saved.backend);
-  if (backend.needsCommandFile) {
-    const cmdPath = commandJsonPath(id);
-    if (options.writeCommand || !existsSync(cmdPath)) {
-      await writeJson(cmdPath, { argv: saved.commandArgv ?? [] });
-    }
-  }
+  // Note: command.json is no longer written — the server command is computed
+  // fresh from the profile config at launch time (see computeServerCommand in
+  // process.mjs).  commandArgv is kept in the profile for backwards compat.
 
   if (!existsSync(notesPath(id))) {
     await writeFile(notesPath(id), `# ${saved.label}\n\nNotes for this model profile.\n`, "utf8");

package/src/benchmark/pi-runner.mjs

@@ -1,257 +0,0 @@
-// ── Run benchmark in Pi (non-interactive JSON mode) ───────────────────────────
-
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import {
-  BENCH_COLORS, renderStreamEvent,
-  formatToolCall, printFinalLine, stopExecTimer,
-} from "./stream-renderer.mjs";
-import { piModelString } from "./shared.mjs";
-
-export async function runBenchmarkInPi(profile, runDirectory, { signal } = {}) {
-  const model = piModelString(profile);
-  const args = ["--model", model, "--mode", "json", "-p", "@prompt.md"];
-
-  const child = spawn("pi", args, {
-    cwd: runDirectory,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  const runResult = {
-    model,
-    exitCode: null,
-    wallClockMs: null,
-    agentTurns: 0,
-    promptTokens: 0,
-    completionTokens: 0,
-    totalTokens: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    toolCalls: 0,
-    toolResults: 0,
-    perTurn: [],
-    rawResponseLines: [],
-    error: null,
-  };
-
-  let streamBuffer = "";
-  let responseBuffer = "";
-  let currentTurnStartMs = null;
-  let lastTurnEndMs = null;
-  let runStartMs = null;
-  let firstEventMs = null;
-  let lastEventMs = null;
-  let cancelled = false;
-
-  const streamPath = join(runDirectory, "stream.ndjson");
-  const stderrPath = join(runDirectory, "stderr.log");
-  const responsePath = join(runDirectory, "response.raw.txt");
-
-  const streamHandle = await openFileHandle(streamPath, "w");
-  const stderrHandle = await openFileHandle(stderrPath, "w");
-
-  const verbose = Boolean(process.env.OFFGRID_BENCHMARK_VERBOSE);
-  const renderState = {
-    cwd: runDirectory,
-    turn: 0,
-    turnHadToolError: false,
-    modelPrinted: false,
-    activeTool: null,
-    execTimer: null,
-    status: { mode: "idle", toolName: null, bytes: 0, tokens: 0, execStartedAt: null },
-  };
-
-  function appendResponse(text) {
-    responseBuffer += text;
-  }
-
-  function flushResponse() {
-    if (responseBuffer) {
-      runResult.rawResponseLines.push(responseBuffer);
-      responseBuffer = "";
-    }
-  }
-
-  function updateTimeBounds(timestamp) {
-    if (!timestamp) return;
-    if (firstEventMs === null) firstEventMs = timestamp;
-    lastEventMs = timestamp;
-  }
-
-  function beginTurn() {
-    runResult.agentTurns += 1;
-    currentTurnStartMs = lastTurnEndMs ?? runStartMs ?? null;
-  }
-
-  function endTurn(usage, timestamp) {
-    const turnEndMs = timestamp ?? null;
-    const wallClockMs = currentTurnStartMs && turnEndMs ? turnEndMs - currentTurnStartMs : null;
-    runResult.perTurn.push({
-      turn: runResult.agentTurns,
-      inputTokens: usage?.input ?? 0,
-      outputTokens: usage?.output ?? 0,
-      cacheRead: usage?.cacheRead ?? 0,
-      cacheWrite: usage?.cacheWrite ?? 0,
-      wallClockMs,
-      toolCalls: 0,
-    });
-    if (turnEndMs) lastTurnEndMs = turnEndMs;
-    currentTurnStartMs = null;
-  }
-
-  function processLine(line) {
-    if (!line.trim()) return;
-    streamHandle.write(line + "\n");
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch (err) {
-      console.log(BENCH_COLORS.error(`[parse error] ${err.message}`));
-      return;
-    }
-
-    const timestamp = extractTimestamp(parsed);
-    updateTimeBounds(timestamp);
-
-    renderStreamEvent(parsed, renderState, { verbose });
-
-    if (parsed.type === "session" || parsed.type === "agent_start") {
-      if (timestamp && runStartMs === null) runStartMs = timestamp;
-    }
-
-    if (parsed.type === "turn_start") {
-      beginTurn();
-    }
-
-    if (parsed.type === "turn_end" && parsed.message?.usage) {
-      const usage = parsed.message.usage;
-      runResult.promptTokens += usage.input ?? 0;
-      runResult.completionTokens += usage.output ?? 0;
-      runResult.cacheRead += usage.cacheRead ?? 0;
-      runResult.cacheWrite += usage.cacheWrite ?? 0;
-      endTurn(usage, timestamp);
-    }
-
-    if (parsed.type === "message_update" && parsed.assistantMessageEvent) {
-      const evt = parsed.assistantMessageEvent;
-      const subtype = String(evt.type ?? "").replace(/_/gu, "");
-      if (subtype === "thinkingdelta" || subtype === "textdelta") {
-        appendResponse(evt.delta || "");
-      }
-    }
-
-    if (parsed.type === "message_end" && parsed.message?.role === "assistant") {
-      flushResponse();
-      const content = parsed.message.content ?? [];
-      for (const item of content) {
-        if (item.type === "toolCall") {
-          runResult.toolCalls += 1;
-          appendResponse(`\n${formatToolCall(item)}\n`);
-          const currentTurn = runResult.perTurn[runResult.perTurn.length - 1];
-          if (currentTurn) currentTurn.toolCalls += 1;
-        }
-      }
-    }
-
-    if (parsed.type === "toolResult") {
-      runResult.toolResults += 1;
-      const status = parsed.isError ? "error" : "ok";
-      appendResponse(`\n[toolResult] ${parsed.toolName} (${status})\n`);
-    }
-
-    if (parsed.type === "agent_end") {
-      flushResponse();
-    }
-  }
-
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    streamBuffer += chunk;
-    const lines = streamBuffer.split("\n");
-    streamBuffer = lines.pop();
-    for (const line of lines) {
-      processLine(line);
-    }
-  });
-
-  child.stderr.setEncoding("utf8");
-  child.stderr.on("data", (chunk) => {
-    stderrHandle.write(chunk);
-  });
-
-  const abortListener = () => {
-    if (cancelled) return;
-    cancelled = true;
-    console.log(BENCH_COLORS.error("\n\n[Cancelled by user]"));
-    child.kill("SIGTERM");
-  };
-
-  if (signal) {
-    signal.addEventListener("abort", abortListener);
-  }
-
-  return new Promise((resolve) => {
-    child.on("exit", async (code) => {
-      if (signal) signal.removeEventListener("abort", abortListener);
-      stopExecTimer(renderState);
-      if (streamBuffer.trim()) {
-        processLine(streamBuffer);
-      }
-      flushResponse();
-      await streamHandle.close();
-      await stderrHandle.close();
-      await writeFile(responsePath, runResult.rawResponseLines.join(""), "utf8");
-
-      runResult.exitCode = code ?? 0;
-      if (firstEventMs !== null && lastEventMs !== null) {
-        runResult.wallClockMs = lastEventMs - firstEventMs;
-      }
-
-      if (cancelled) {
-        runResult.error = { message: "Cancelled by user" };
-        resolve(runResult);
-        return;
-      }
-
-      printFinalLine(BENCH_COLORS.info("Pi benchmark finished"));
-
-      if (runResult.exitCode !== 0) {
-        runResult.error = { message: `Pi exited with code ${runResult.exitCode}` };
-        resolve(runResult);
-        return;
-      }
-
-      resolve(runResult);
-    });
-
-    child.on("error", async (err) => {
-      if (signal) signal.removeEventListener("abort", abortListener);
-      stopExecTimer(renderState);
-      await streamHandle.close();
-      await stderrHandle.close();
-      runResult.error = { message: err.message };
-      resolve(runResult);
-    });
-  });
-}
-
-function extractTimestamp(event) {
-  const raw = event?.message?.timestamp ?? event?.timestamp ?? event?.assistantMessageEvent?.partial?.timestamp;
-  if (typeof raw === "number") return raw;
-  if (typeof raw === "string") {
-    const parsed = Date.parse(raw);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  const iso = event?.message?.createdAt ?? event?.createdAt ?? event?.created_at;
-  if (typeof iso === "string") {
-    const parsed = Date.parse(iso);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return null;
-}
-
-async function openFileHandle(path, flags) {
-  const { open } = await import("node:fs/promises");
-  return open(path, flags);
-}

package/src/benchmark/stream-renderer.mjs

@@ -1,302 +0,0 @@
-// ── Semantic stream renderer for Pi benchmark output ─────────────────────────
-
-import { relative, basename } from "node:path";
-import { pc } from "../ui.mjs";
-
-export const BENCH_COLORS = {
-  thinking: pc.magenta,
-  text: pc.green,
-  tool: pc.yellow,
-  success: pc.green,
-  warning: pc.yellow,
-  toolOutput: pc.dim,
-  error: pc.red,
-  info: pc.cyan,
-  dim: pc.dim,
-};
-
-export function formatToolCall(toolCall) {
-  const path = toolCall.arguments?.path || toolCall.arguments?.file_path || toolCall.arguments?.filename || "";
-  const summary = path ? ` → ${path}` : "";
-  return `[toolCall] ${toolCall.name}${summary}`;
-}
-
-export function formatTokens(n) {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1_000) return `${Math.round(n / 1_000)}k`;
-  return String(Math.round(n));
-}
-
-export function estimatedTokensFromBytes(bytes) {
-  return Math.max(1, Math.ceil(bytes / 4));
-}
-
-export function clearStatusLine() {
-  if (process.stdout.isTTY) {
-    process.stdout.write("\r\x1b[K");
-  }
-}
-
-export function printStatusLine(text) {
-  if (process.stdout.isTTY) {
-    process.stdout.write(`\r\x1b[K${text}`);
-  }
-}
-
-export function printFinalLine(text) {
-  clearStatusLine();
-  console.log(text);
-}
-
-export function renderStreamEvent(parsed, state, opts = {}) {
-  const verbose = Boolean(opts.verbose);
-  const type = parsed.type;
-
-  switch (type) {
-    case "session":
-      printFinalLine(BENCH_COLORS.info("Pi benchmark started"));
-      if (parsed.id) printFinalLine(BENCH_COLORS.dim(`  Session  ${parsed.id}`));
-      break;
-    case "agent_start":
-      break;
-    case "turn_start": {
-      state.turn += 1;
-      state.turnHadToolError = false;
-      resetStatus(state, "thinking");
-      printFinalLine("");
-      printFinalLine(BENCH_COLORS.info(`Turn ${state.turn}`));
-      break;
-    }
-    case "message_start": {
-      const msg = parsed.message;
-      if (!state.modelPrinted && msg?.role === "assistant" && msg.provider && msg.model) {
-        state.modelPrinted = true;
-        printFinalLine(BENCH_COLORS.dim(`  Model    ${msg.provider}/${msg.model}`));
-      }
-      break;
-    }
-    case "message_update": {
-      const evt = parsed.assistantMessageEvent;
-      if (!evt) return;
-      const subtype = String(evt.type ?? "").replace(/_/gu, "");
-      if (subtype === "thinkingstart") {
-        resetStatus(state, "thinking");
-      } else if (subtype === "thinkingdelta") {
-        if (verbose) process.stdout.write(BENCH_COLORS.thinking(evt.delta || ""));
-        updateStatusFromDelta(state, evt.delta, "thinking");
-      } else if (subtype === "textstart") {
-        resetStatus(state, "text");
-      } else if (subtype === "textdelta") {
-        if (verbose) process.stdout.write(BENCH_COLORS.text(evt.delta || ""));
-        updateStatusFromDelta(state, evt.delta, "text");
-      } else if (subtype === "toolcallstart") {
-        resetStatus(state, "tool");
-      } else if (subtype === "toolcalldelta") {
-        if (verbose) process.stdout.write(BENCH_COLORS.tool(evt.delta || ""));
-        updateStatusFromDelta(state, evt.delta, "tool");
-      }
-      break;
-    }
-    case "message_end":
-      break;
-    case "tool_execution_start": {
-      state.activeTool = {
-        name: parsed.toolName,
-        args: parsed.args ?? {},
-        outputText: "",
-      };
-      resetStatus(state, "exec", parsed.toolName);
-      printFinalLine(BENCH_COLORS.tool(formatToolStart(parsed.toolName, parsed.args ?? {}, state)));
-      startExecTimer(state);
-      break;
-    }
-    case "tool_execution_update": {
-      const text = toolResultText(parsed.partialResult ?? parsed.result ?? parsed);
-      if (text) {
-        if (verbose) process.stdout.write(BENCH_COLORS.toolOutput(text));
-        if (state.activeTool) state.activeTool.outputText = text;
-        state.status.bytes += Buffer.byteLength(text, "utf8");
-        printExecStatus(state);
-      }
-      break;
-    }
-    case "tool_execution_end": {
-      stopExecTimer(state);
-      const lines = formatToolEnd(parsed, state);
-      if (parsed.isError) state.turnHadToolError = true;
-      for (const line of lines) printFinalLine(line);
-      state.activeTool = null;
-      resetStatus(state, "idle");
-      break;
-    }
-    case "toolResult": {
-      if (parsed.isError) state.turnHadToolError = true;
-      const status = parsed.isError ? BENCH_COLORS.error("✗") : BENCH_COLORS.success("✓");
-      printFinalLine(`${status} ${parsed.toolName ?? "tool"}`);
-      break;
-    }
-    case "turn_end": {
-      stopExecTimer(state);
-      const usage = parsed.message?.usage;
-      const tokenPart = usage ? ` · ${formatTokens(usage.output ?? usage.totalTokens ?? 0)} tokens` : "";
-      const marker = state.turnHadToolError ? BENCH_COLORS.warning("⚠") : BENCH_COLORS.success("✓");
-      const suffix = state.turnHadToolError ? " · tool issue" : "";
-      printFinalLine(`${marker} turn ${state.turn}${tokenPart}${suffix}`);
-      break;
-    }
-    case "agent_end":
-      stopExecTimer(state);
-      break;
-    default:
-      break;
-  }
-}
-
-export function resetStatus(state, mode, toolName = null) {
-  state.status.mode = mode;
-  state.status.toolName = toolName;
-  state.status.bytes = 0;
-  state.status.tokens = 0;
-}
-
-export function updateStatusFromDelta(state, delta, mode = state.status.mode) {
-  if (!delta) return;
-  state.status.mode = mode;
-  state.status.bytes += Buffer.byteLength(delta, "utf8");
-  state.status.tokens = estimatedTokensFromBytes(state.status.bytes);
-  const label = state.status.toolName ? ` · ${state.status.toolName}` : "";
-  const modeLabel = {
-    thinking: "thinking…",
-    text: "drafting response…",
-    tool: "preparing tool…",
-    exec: "running tool…",
-  }[state.status.mode] ?? "working…";
-  const bytes = formatBytes(state.status.bytes);
-  const tokens = formatTokens(state.status.tokens);
-  printStatusLine(BENCH_COLORS.dim(`Turn ${state.turn} ${modeLabel}${label} · ${bytes} (~${tokens} tokens)`));
-}
-
-export function startExecTimer(state) {
-  stopExecTimer(state);
-  state.status.execStartedAt = Date.now();
-  state.status.bytes = 0;
-  if (!process.stdout.isTTY) return;
-  printExecStatus(state);
-  state.execTimer = setInterval(() => printExecStatus(state), 1000);
-}
-
-export function stopExecTimer(state) {
-  if (state.execTimer) {
-    clearInterval(state.execTimer);
-    state.execTimer = null;
-  }
-  clearStatusLine();
-}
-
-export function printExecStatus(state) {
-  if (!process.stdout.isTTY) return;
-  const elapsed = state.status.execStartedAt ? Math.floor((Date.now() - state.status.execStartedAt) / 1000) : 0;
-  const tool = state.status.toolName ?? "tool";
-  const bytes = formatBytes(state.status.bytes);
-  printStatusLine(BENCH_COLORS.dim(`Turn ${state.turn} running ${tool}… ${elapsed}s · ${bytes}`));
-}
-
-export function formatToolStart(toolName, args, state) {
-  if (toolName === "read") return `→ read ${displayPath(args.path, state)}`;
-  if (toolName === "write") {
-    const size = args.content ? ` · ${formatBytes(Buffer.byteLength(String(args.content), "utf8"))}` : "";
-    return `→ write ${displayPath(args.path, state)}${size}`;
-  }
-  if (toolName === "edit") {
-    const count = Array.isArray(args.edits) ? args.edits.length : 0;
-    const suffix = count > 0 ? ` · ${count} replacement${count === 1 ? "" : "s"}` : "";
-    return `→ edit ${displayPath(args.path, state)}${suffix}`;
-  }
-  if (toolName === "bash") return `→ run ${truncateOneLine(args.command ?? "")}`;
-  return `→ ${toolName}${compactArgs(args)}`;
-}
-
-export function formatToolEnd(parsed, state) {
-  const toolName = parsed.toolName ?? state.activeTool?.name ?? "tool";
-  const args = parsed.args ?? state.activeTool?.args ?? {};
-  const text = toolResultText(parsed.result) || state.activeTool?.outputText || "";
-  const marker = parsed.isError ? BENCH_COLORS.error("✗") : BENCH_COLORS.success("✓");
-
-  if (parsed.isError) {
-    return [`${marker} ${toolName} failed · ${firstUsefulLine(text)}`];
-  }
-
-  if (toolName === "write") return [`${marker} wrote ${displayPath(args.path, state)}${parsedWriteSize(text)}`];
-  if (toolName === "read") return [`${marker} read ${displayPath(args.path, state)}${text ? ` · ${formatBytes(Buffer.byteLength(text, "utf8"))}` : ""}`];
-  if (toolName === "edit") return [`${marker} edited ${displayPath(args.path, state)}`];
-  if (toolName === "bash") return formatBashResult(marker, text);
-
-  const summary = firstUsefulLine(text);
-  return [`${marker} ${toolName}${summary ? ` · ${summary}` : ""}`];
-}
-
-export function formatBashResult(marker, text) {
-  const lines = meaningfulLines(text).slice(0, 2);
-  if (lines.length === 0) return [`${marker} command completed`];
-  return [`${marker} ${lines[0]}`, ...lines.slice(1).map((line) => BENCH_COLORS.dim(`  ${line}`))];
-}
-
-export function parsedWriteSize(text) {
-  const match = String(text).match(/Successfully wrote\s+([0-9,]+)\s+bytes/iu);
-  if (!match) return "";
-  const bytes = Number(match[1].replace(/,/gu, ""));
-  return Number.isFinite(bytes) ? ` · ${formatBytes(bytes)}` : "";
-}
-
-export function toolResultText(result) {
-  const content = result?.content;
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .map((item) => typeof item?.text === "string" ? item.text : "")
-    .filter(Boolean)
-    .join("\n");
-}
-
-export function firstUsefulLine(text) {
-  return meaningfulLines(text)[0] ?? "no details";
-}
-
-export function meaningfulLines(text) {
-  const lines = String(text ?? "")
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .filter((line) => !/^\^+$/u.test(line));
-  const errorLine = lines.find((line) => /(?:error|exception|failed|not found|command exited with code|validation failed)/iu.test(line));
-  if (errorLine) return [errorLine, ...lines.filter((line) => line !== errorLine)];
-  return lines;
-}
-
-export function displayPath(value, state) {
-  if (!value) return "unknown";
-  const path = String(value);
-  const rel = state.cwd ? relative(state.cwd, path) : path;
-  if (rel && !rel.startsWith("..") && rel !== ".") return rel;
-  return basename(path) || path;
-}
-
-export function compactArgs(args) {
-  const entries = Object.entries(args ?? {}).filter(([, value]) => value !== undefined && value !== null && value !== "");
-  if (entries.length === 0) return "";
-  return ` · ${truncateOneLine(entries.map(([key, value]) => `${key}=${String(value)}`).join(" "))}`;
-}
-
-export function truncateOneLine(value, max = Math.max(60, Math.min(process.stdout.columns ?? 100, 140) - 12)) {
-  const text = String(value ?? "").replace(/\s+/gu, " ").trim();
-  return text.length > max ? `${text.slice(0, Math.max(1, max - 1))}…` : text;
-}
-
-export function formatBytes(bytes) {
-  if (!Number.isFinite(bytes)) return "unknown";
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  let size = bytes;
-  let unit = 0;
-  while (size >= 1024 && unit < units.length - 1) { size /= 1024; unit += 1; }
-  return `${size.toFixed(unit === 0 ? 0 : 2)} ${units[unit]}`;
-}