offgrid-ai 0.13.0 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offgrid-ai",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "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/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 });
 
@@ -138,6 +128,28 @@ export async function runPreparedBenchmark(profile, runDirectory, options = {})
   return metadata;
 }
 
+// ── Shared benchmark selection ────────────────────────────────────────────
+
+async function selectBenchmark(prompt, repoPath) {
+  const kind = await prompt.choice("Benchmark category", [
+    { value: "visual", label: "Visual Benchmark", hint: "HTML/CSS/JS animation benchmarks" },
+    { value: "data-science", label: "Data Science", hint: "Analysis and charting benchmarks" },
+  ], "visual");
+
+  const benchDir = join(repoPath, "benchmarks");
+  const benchmarks = (await loadBenchmarks(benchDir)).filter((b) => b.kind === kind);
+  if (benchmarks.length === 0) {
+    console.log(pc.yellow(`No ${kind} benchmarks found in ${benchDir}`));
+    return null;
+  }
+  const benchmarkId = await prompt.choice("Prompt", benchmarks.map((b) => ({
+    value: b.id, label: b.title, hint: b.description || b.id,
+  })), benchmarks[0].id);
+  const benchmark = benchmarks.find((b) => b.id === benchmarkId);
+  if (!benchmark) return null;
+  return { kind, benchmark };
+}
+
 // ── Benchmark from a selected profile (from model picker) ────────────────
 
 export async function benchmarkForProfile(profile) {
@@ -147,28 +159,15 @@ export async function benchmarkForProfile(profile) {
     const repoPath = await linkBenchmarkRepo(prompt);
     if (!repoPath) return;
 
-    const kind = await prompt.choice("Benchmark category", [
-      { value: "visual", label: "Visual Benchmark", hint: "HTML/CSS/JS animation benchmarks" },
-      { value: "data-science", label: "Data Science", hint: "Analysis and charting benchmarks" },
-    ], "visual");
-
-    const benchDir = join(repoPath, "benchmarks");
-    const benchmarks = (await loadBenchmarks(benchDir)).filter((b) => b.kind === kind);
-    if (benchmarks.length === 0) {
-      console.log(pc.yellow(`No ${kind} benchmarks found in ${benchDir}`));
-      return;
-    }
-    const benchmarkId = await prompt.choice("Prompt", benchmarks.map((b) => ({
-      value: b.id, label: b.title, hint: b.description || b.id,
-    })), benchmarks[0].id);
-    const selectedBenchmark = benchmarks.find((b) => b.id === benchmarkId);
-    if (!selectedBenchmark) return;
+    const selected = await selectBenchmark(prompt, repoPath);
+    if (!selected) return;
+    const { kind, benchmark: selectedBenchmark } = selected;
 
     const modelId = profile.modelAlias;
     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" });
@@ -187,28 +186,14 @@ export async function benchmarkForProfile(profile) {
 
 export async function benchmarkFlow() {
   await ensureDirs();
-
   const prompt = createPrompt();
   try {
     const repoPath = await linkBenchmarkRepo(prompt);
     if (!repoPath) return;
 
-    const kind = await prompt.choice("Benchmark category", [
-      { value: "visual", label: "Visual Benchmark", hint: "HTML/CSS/JS animation benchmarks" },
-      { value: "data-science", label: "Data Science", hint: "Analysis and charting benchmarks" },
-    ], "visual");
-
-    const benchDir = join(repoPath, "benchmarks");
-    const benchmarks = (await loadBenchmarks(benchDir)).filter((b) => b.kind === kind);
-    if (benchmarks.length === 0) {
-      console.log(pc.yellow(`No ${kind} benchmarks found in ${benchDir}`));
-      return;
-    }
-    const benchmarkId = await prompt.choice("Prompt", benchmarks.map((b) => ({
-      value: b.id, label: b.title, hint: b.description || b.id,
-    })), benchmarks[0].id);
-    const selectedBenchmark = benchmarks.find((b) => b.id === benchmarkId);
-    if (!selectedBenchmark) return;
+    const selected = await selectBenchmark(prompt, repoPath);
+    if (!selected) return;
+    const { kind, benchmark: selectedBenchmark } = selected;
 
     const profiles = await loadProfiles();
     const source = await prompt.choice("Model source", [
@@ -238,7 +223,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

@@ -3,7 +3,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { pc, renderRows, renderSection } from "../ui.mjs";
-import { slugModelId, createRunId, buildToolPrompt } from "./shared.mjs";
+import { slugModelId, createRunId } from "./shared.mjs";
 import { parseModelName } from "../model-name.mjs";
 
 function harnessDisplayName(id) {
@@ -30,7 +30,7 @@ function printBenchmarkNextSteps({ repoPath, runDirectory, profile, modelId, run
 }
 
 export async function prepareBenchmarkRun({ repoPath, benchmark, kind, modelId, modelSource, backendLabel, profile, showNextSteps = true }) {
-  const toolPrompt = buildToolPrompt(benchmark);
+  const toolPrompt = benchmark.prompt;
   const now = new Date();
   const runId = createRunId(now);
   const modelSlug = slugModelId(modelId);
@@ -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,363 @@
+// ── 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, formatBytes } from "../ui.mjs";
+import { piApiModelId, modelReasoning, modelCompat } 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 reasoning = modelReasoning(profile) ?? false;
+  const compat = modelCompat(profile);
+
+  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",
+      ...(compat ?? {}),
+    },
+  };
+}
+
+// ── 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 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/shared.mjs

@@ -18,10 +18,6 @@ export function createRunId(date = new Date()) {
   return date.toISOString().replace(/:/gu, "-").replace(/\./gu, "-");
 }
 
-export function buildToolPrompt(benchmark) {
-  return benchmark.prompt;
-}
-
 export async function loadBenchmarks(benchDir) {
   const entries = await readdir(benchDir);
   const markdownFiles = entries.filter((f) => f.endsWith(".md")).sort();
@@ -47,8 +43,4 @@ export async function loadBenchmarks(benchDir) {
     benchmarks.push({ id, title, description, prompt: content, kind });
   }
   return benchmarks;
-}
-
-export function piModelString(profile) {
-  return profile.harnesses?.pi?.model ?? `${profile.providerId}/${profile.modelAlias}`;
 }

package/src/benchmark.mjs

@@ -1,10 +1,10 @@
 // ── Benchmark module (thin facade) ──────────────────────────────────────────
 // Submodules handle the actual logic. This file re-exports for backward compatibility.
 
-export { slugModelId, createRunId, buildToolPrompt, loadBenchmarks, piModelString } from "./benchmark/shared.mjs";
+export { slugModelId, createRunId, loadBenchmarks } 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/commands/run.mjs

@@ -149,18 +149,6 @@ function textOnlyProfile(profile) {
     mmprojPath: null,
     disabledMmprojPath: profile.disabledMmprojPath ?? profile.mmprojPath,
     capabilities: { ...(profile.capabilities ?? {}), vision: false, visionDisabledReason: "unsupported-mmproj" },
-    commandArgv: removeCommandOption(profile.commandArgv ?? [], "--mmproj"),
   });
 }
 
-function removeCommandOption(argv, flag) {
-  const next = [];
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] === flag) {
-      if (argv[i + 1] && !argv[i + 1].startsWith("--")) i += 1;
-      continue;
-    }
-    next.push(argv[i]);
-  }
-  return next;
-}

package/src/harness-pi.mjs

@@ -118,7 +118,7 @@ function modelInput(profile) {
   return ["text"];
 }
 
-function modelCompat(profile) {
+export function modelCompat(profile) {
   if (profile.compat) return profile.compat;
   const family = modelFamily(profile);
   if (family.includes("qwen") || family.includes("gemma-4") || family.includes("gemma 4")) {
@@ -127,14 +127,14 @@ function modelCompat(profile) {
   return null;
 }
 
-function modelReasoning(profile) {
+export function modelReasoning(profile) {
   if (profile.reasoning !== undefined) return Boolean(profile.reasoning);
   const family = modelFamily(profile);
   if (family.includes("qwen") || family.includes("gemma-4") || family.includes("gemma 4")) return true;
   return undefined;
 }
 
-function modelFamily(profile) {
+export function modelFamily(profile) {
   return [profile.id, profile.label, profile.modelAlias, profile.modelPath, profile.omlxModel].filter(Boolean).join(" ").toLowerCase();
 }
 

package/src/model-presenters.mjs

@@ -159,21 +159,6 @@ export function modelSelectOption(item, { runningProfilesNow, modelMissingIds, n
       ...(hint ? { hint: pc.red(hint) } : {}),
     };
   }
-  if (item.type === "new") {
-    return {
-      value: itemKey(item),
-      label: optionLabel({
-        status: optionStatusTag("setup"),
-        backend: optionBackendTag(backendId),
-        source: optionSourceTag(sourceId),
-        name: item.label,
-        nameWidth,
-        quant: optionQuantLabel(item),
-        ctx: optionCtxLabel(item),
-        size: optionSizeLabel(item),
-      }),
-    };
-  }
   return {
     value: itemKey(item),
     label: optionLabel({

package/src/process.mjs

@@ -3,7 +3,6 @@ import { promisify } from "node:util";
 import { closeSync, openSync } from "node:fs";
 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, profileDir } from "./profiles.mjs";
 import { backendFor, backendBinaryFor } from "./backends.mjs";
@@ -501,4 +500,9 @@ function timestampForFile() {
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function quoteShell(value) {
+  const text = String(value);
+  return /^[A-Za-z0-9_/@%+=:,.-]+$/u.test(text) ? text : `'${text.replace(/'/gu, ` '"'"'`)}'`;
 }