local-executor 0.1.0

package/dist/cli.js

@@ -0,0 +1,2606 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/util/fs.ts
+import { access as access2, cp, mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join as join3, resolve, sep } from "path";
+async function exists(p2) {
+  try {
+    await access2(p2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(p2) {
+  try {
+    return (await stat(p2)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(p2) {
+  await mkdir(p2, { recursive: true });
+}
+async function readJson(p2) {
+  return JSON.parse(await readFile(p2, "utf8"));
+}
+async function readJsonOr(p2, fallback) {
+  try {
+    return await readJson(p2);
+  } catch {
+    return fallback;
+  }
+}
+async function writeJson(p2, value) {
+  await ensureDir(dirname(p2));
+  await writeFile(p2, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function writeText(p2, content) {
+  await ensureDir(dirname(p2));
+  await writeFile(p2, content, "utf8");
+}
+async function readTextOr(p2, fallback = "") {
+  try {
+    return await readFile(p2, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+async function copyDir(src, dest) {
+  await ensureDir(dest);
+  await cp(src, dest, { recursive: true, force: true });
+  return listFiles(dest);
+}
+async function listFiles(dir) {
+  const out = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const p2 = join3(dir, e.name);
+    if (e.isDirectory()) out.push(...await listFiles(p2));
+    else out.push(p2);
+  }
+  return out.sort();
+}
+async function removePath(p2) {
+  await rm(p2, { recursive: true, force: true });
+}
+function home() {
+  return homedir();
+}
+function contractTilde(p2) {
+  const h = home();
+  if (p2 === h) return "~";
+  if (p2.startsWith(h + sep)) return `~${p2.slice(h.length)}`;
+  return p2;
+}
+function toPosix(p2) {
+  return p2.split("\\").join("/");
+}
+async function findGitRoot(start) {
+  let dir = resolve(start);
+  for (; ; ) {
+    if (await exists(join3(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+var init_fs = __esm({
+  "src/util/fs.ts"() {
+    "use strict";
+  }
+});
+
+// src/util/state.ts
+var state_exports = {};
+__export(state_exports, {
+  cacheDir: () => cacheDir,
+  emptyManifest: () => emptyManifest,
+  installKey: () => installKey,
+  lexHome: () => lexHome,
+  manifestPath: () => manifestPath,
+  readManifest: () => readManifest,
+  upsertInstall: () => upsertInstall,
+  writeManifest: () => writeManifest
+});
+import { join as join4 } from "path";
+function lexHome() {
+  return process.env.LEX_HOME ?? join4(home(), ".local-executor");
+}
+function manifestPath() {
+  return join4(lexHome(), "manifest.json");
+}
+function cacheDir() {
+  return join4(lexHome(), "cache");
+}
+async function readManifest() {
+  const m = await readJsonOr(manifestPath(), emptyManifest());
+  if (!Array.isArray(m.installs)) m.installs = [];
+  return m;
+}
+async function writeManifest(m) {
+  m.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeJson(manifestPath(), m);
+}
+function installKey(rec) {
+  const anchor = rec.scope === "project" ? rec.owned[0] ?? rec.marked[0] ?? "" : "";
+  return `${rec.agent}|${rec.scope}|${rec.root}|${anchor}`;
+}
+function upsertInstall(m, rec) {
+  const key = installKey(rec);
+  const rest = m.installs.filter((r) => installKey(r) !== key);
+  return { ...m, installs: [...rest, rec] };
+}
+var emptyManifest;
+var init_state = __esm({
+  "src/util/state.ts"() {
+    "use strict";
+    init_fs();
+    emptyManifest = () => ({
+      schema: 1,
+      installs: [],
+      updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+    });
+  }
+});
+
+// src/cli.ts
+import { Command, Option } from "commander";
+
+// src/agents/types.ts
+var allAgents = ["claude", "codex", "cursor", "windsurf"];
+var agentNames = {
+  claude: "Claude Code",
+  codex: "Codex CLI",
+  cursor: "Cursor",
+  windsurf: "Windsurf"
+};
+function parseAgentList(input) {
+  const out = [];
+  for (const raw of input.split(",")) {
+    const s = raw.trim().toLowerCase();
+    if (!s) continue;
+    const id = s === "claude-code" ? "claude" : s === "codex-cli" ? "codex" : s;
+    if (!allAgents.includes(id)) {
+      throw new Error(`Unknown agent "${raw.trim()}". Choose from: ${allAgents.join(", ")}`);
+    }
+    if (!out.includes(id)) out.push(id);
+  }
+  return out;
+}
+
+// src/commands/doctor.ts
+import { join as join5 } from "path";
+
+// src/ollama/client.ts
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var OllamaClient = class {
+  baseUrl;
+  fetchImpl;
+  constructor(baseUrl = DEFAULT_OLLAMA_URL, fetchImpl = (i, o) => fetch(i, o)) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = fetchImpl;
+  }
+  /** Server version, or null when unreachable. Never throws. */
+  async version(timeoutMs = 3e3) {
+    try {
+      const res = await this.fetchImpl(`${this.baseUrl}/api/version`, {
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      return data.version ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async isUp(timeoutMs = 3e3) {
+    return await this.version(timeoutMs) !== null;
+  }
+  /** Models present locally. Throws when the server is unreachable. */
+  async list() {
+    const res = await this.fetchImpl(`${this.baseUrl}/api/tags`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) throw new Error(`Ollama /api/tags returned HTTP ${res.status}`);
+    const data = await res.json();
+    return (data.models ?? []).map((m) => ({ name: m.name, sizeBytes: m.size ?? 0 }));
+  }
+  async hasModel(tag) {
+    const models = await this.list();
+    return models.some((m) => m.name === tag || m.name === `${tag}:latest`);
+  }
+  /**
+   * Pull a model with streaming progress. Calls `onEvent` for every NDJSON line.
+   * Resolves when the stream ends with a success status; rejects on error.
+   */
+  async pull(tag, onEvent, signal) {
+    const res = await this.fetchImpl(`${this.baseUrl}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: tag, stream: true }),
+      ...signal ? { signal } : {}
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Ollama /api/pull failed: HTTP ${res.status} ${await safeText(res)}`);
+    }
+    let sawSuccess = false;
+    for await (const event of ndjson(res.body)) {
+      const e = event;
+      if (e.error) throw new Error(`Ollama pull error: ${e.error}`);
+      onEvent(e);
+      if (e.status === "success") sawSuccess = true;
+    }
+    if (!sawSuccess) throw new Error("Ollama pull stream ended without a success status");
+  }
+  /** One short generation to load the model and measure throughput. */
+  async warmup(tag, keepAlive = "30m", timeoutMs = 18e4) {
+    const res = await this.fetchImpl(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: tag,
+        prompt: "Write a JavaScript one-liner that returns the sum of an array. Reply with code only.",
+        stream: false,
+        keep_alive: keepAlive,
+        options: { num_predict: 64, temperature: 0 }
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok)
+      throw new Error(`Ollama /api/generate failed: HTTP ${res.status} ${await safeText(res)}`);
+    const data = await res.json();
+    const evalCount = data.eval_count ?? 0;
+    const evalNs = data.eval_duration ?? 0;
+    return {
+      tokensPerSec: evalNs > 0 ? Math.round(evalCount / (evalNs / 1e9) * 10) / 10 : null,
+      evalCount,
+      evalDurationMs: Math.round(evalNs / 1e6),
+      loadDurationMs: Math.round((data.load_duration ?? 0) / 1e6),
+      totalDurationMs: Math.round((data.total_duration ?? 0) / 1e6),
+      reply: data.response ?? ""
+    };
+  }
+  /** Poll until the server answers or the deadline passes. */
+  async waitUntilUp(timeoutMs = 3e4, intervalMs = 500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (await this.isUp(1500)) return true;
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    return false;
+  }
+};
+async function safeText(res) {
+  try {
+    return (await res.text()).slice(0, 300);
+  } catch {
+    return "";
+  }
+}
+async function* ndjson(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let nl = buffer.indexOf("\n");
+    while (nl >= 0) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (line) yield JSON.parse(line);
+      nl = buffer.indexOf("\n");
+    }
+  }
+  const rest = buffer.trim();
+  if (rest) yield JSON.parse(rest);
+}
+
+// src/ollama/release.ts
+import { join } from "path";
+var OLLAMA_RELEASES_API = "https://api.github.com/repos/ollama/ollama/releases/latest";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function releaseCachePath(cacheDir2) {
+  return join(cacheDir2, "ollama-release.json");
+}
+async function latestOllamaVersion(deps) {
+  const cached2 = await deps.readCache().catch(() => null);
+  if (cached2 && deps.now() - cached2.fetchedAt < CACHE_TTL_MS) return cached2.tag;
+  try {
+    const res = await deps.fetchImpl(OLLAMA_RELEASES_API, {
+      headers: { Accept: "application/vnd.github+json", "User-Agent": "local-executor" },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) return cached2?.tag ?? null;
+    const data = await res.json();
+    if (!data.tag_name) return cached2?.tag ?? null;
+    await deps.writeCache({ tag: data.tag_name, fetchedAt: deps.now() }).catch(() => void 0);
+    return data.tag_name;
+  } catch {
+    return cached2?.tag ?? null;
+  }
+}
+function parseVersion(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return null;
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function isOutdated(installed, latest) {
+  const c = compareVersions(installed, latest);
+  return c !== null && c < 0;
+}
+
+// src/util/exec.ts
+import { constants } from "fs";
+import { access } from "fs/promises";
+import { delimiter, join as join2 } from "path";
+import { execa } from "execa";
+async function run(file, args = [], opts = {}) {
+  const options = {
+    reject: false,
+    stdio: opts.inherit ? "inherit" : "pipe",
+    windowsHide: true,
+    ...opts.cwd ? { cwd: opts.cwd } : {},
+    ...opts.env ? { env: opts.env } : {},
+    ...opts.timeoutMs ? { timeout: opts.timeoutMs } : {}
+  };
+  const result = await execa(file, args, options);
+  return {
+    ok: result.exitCode === 0,
+    exitCode: result.exitCode,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    stderr: typeof result.stderr === "string" ? result.stderr : ""
+  };
+}
+async function which(cmd, env = process.env, platform = process.platform) {
+  const pathVar = env.PATH ?? env.Path ?? "";
+  const dirs = pathVar.split(delimiter).filter(Boolean);
+  const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").map((e) => e.toLowerCase()) : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = join2(dir, cmd.toLowerCase().endsWith(ext) && ext ? cmd : cmd + ext);
+      try {
+        await access(candidate, platform === "win32" ? constants.F_OK : constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function spawnDetached(file, args = [], opts = {}) {
+  const options = {
+    detached: true,
+    stdio: "ignore",
+    cleanup: false,
+    windowsHide: true,
+    reject: false,
+    ...opts.cwd ? { cwd: opts.cwd } : {}
+  };
+  execa(file, args, options).unref();
+}
+async function openUrl(url, platform = process.platform) {
+  try {
+    if (platform === "darwin") await execa("open", [url], { reject: false });
+    else if (platform === "win32")
+      await execa("rundll32", ["url.dll,FileProtocolHandler", url], {
+        reject: false,
+        windowsHide: true
+      });
+    else await execa("xdg-open", [url], { reject: false });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function displayCommand(file, args) {
+  const quote = (s) => /[\s"']/.test(s) ? JSON.stringify(s) : s;
+  return [file, ...args].map(quote).join(" ");
+}
+
+// src/commands/doctor.ts
+init_fs();
+
+// src/util/log.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+var ui = { yes: false, json: false, tty: Boolean(process.stdout.isTTY) };
+function configureUi(opts) {
+  Object.assign(ui, opts);
+}
+function nonInteractive() {
+  return ui.yes || ui.json || !ui.tty;
+}
+function silent() {
+  return ui.json;
+}
+function intro2(title) {
+  if (silent()) return;
+  p.intro(pc.bgCyan(pc.black(` ${title} `)));
+}
+function outro2(message2) {
+  if (silent()) return;
+  p.outro(message2);
+}
+function header(step, title, oneLiner) {
+  if (silent()) return;
+  p.log.step(`${pc.bold(pc.cyan(step))} ${pc.bold(title)}
+${pc.dim(oneLiner)}`);
+}
+function info(msg) {
+  if (silent()) return;
+  p.log.info(msg);
+}
+function success(msg) {
+  if (silent()) return;
+  p.log.success(msg);
+}
+function warn(msg) {
+  if (silent()) return;
+  p.log.warn(pc.yellow(msg));
+}
+function error(msg) {
+  if (silent()) {
+    process.stderr.write(`${msg}
+`);
+    return;
+  }
+  p.log.error(pc.red(msg));
+}
+function message(msg) {
+  if (silent()) return;
+  p.log.message(msg);
+}
+function note2(body, title) {
+  if (silent()) return;
+  p.note(body, title);
+}
+function box2(body, title) {
+  if (silent()) return;
+  p.box(body, title, { rounded: true });
+}
+function formatTable(rows) {
+  const width = Math.max(0, ...rows.map(([k]) => k.length));
+  return rows.map(([k, v]) => `${pc.dim(k.padEnd(width))}  ${v}`).join("\n");
+}
+function table(rows) {
+  if (silent()) return;
+  p.log.message(formatTable(rows));
+}
+function code(text3) {
+  return pc.cyan(text3);
+}
+function cancelled() {
+  if (!silent()) p.cancel("Cancelled.");
+  process.exit(130);
+}
+async function confirm2(message2, initial = true) {
+  if (nonInteractive()) return initial;
+  const v = await p.confirm({ message: message2, initialValue: initial });
+  if (p.isCancel(v)) cancelled();
+  return v;
+}
+async function select2(message2, options, initial) {
+  if (nonInteractive()) return initial;
+  const v = await p.select({
+    message: message2,
+    options: options.map(
+      (o) => o.hint === void 0 ? { value: o.value, label: o.label } : o
+    ),
+    initialValue: initial,
+    maxItems: 12
+  });
+  if (p.isCancel(v)) cancelled();
+  return v;
+}
+async function multiselect2(message2, options, initial, required = false) {
+  if (nonInteractive()) return initial;
+  const v = await p.multiselect({
+    message: message2,
+    options: options.map(
+      (o) => o.hint === void 0 ? { value: o.value, label: o.label } : o
+    ),
+    initialValues: initial,
+    required
+  });
+  if (p.isCancel(v)) cancelled();
+  return v;
+}
+async function text2(message2, placeholder, fallback) {
+  if (nonInteractive()) return fallback;
+  const v = await p.text({ message: message2, placeholder, defaultValue: fallback });
+  if (p.isCancel(v)) cancelled();
+  return v || fallback;
+}
+var PLAIN_PROGRESS_INTERVAL_MS = 1e4;
+var noopSpinner = {
+  start: () => void 0,
+  message: () => void 0,
+  stop: () => void 0,
+  error: () => void 0
+};
+function spinner2() {
+  if (silent()) return noopSpinner;
+  if (!ui.tty) {
+    let lastPrinted = 0;
+    return {
+      start: (m) => process.stdout.write(`${m}
+`),
+      message: (m) => {
+        const now = Date.now();
+        if (now - lastPrinted >= PLAIN_PROGRESS_INTERVAL_MS) {
+          lastPrinted = now;
+          process.stdout.write(`  ${m}
+`);
+        }
+      },
+      stop: (m) => process.stdout.write(`${m}
+`),
+      error: (m) => process.stderr.write(`${m}
+`)
+    };
+  }
+  const s = p.spinner();
+  return {
+    start: (m) => s.start(m),
+    message: (m) => s.message(m),
+    stop: (m) => s.stop(m),
+    error: (m) => s.error(m)
+  };
+}
+
+// src/commands/doctor.ts
+init_state();
+async function collectDoctorChecks(ollamaUrl) {
+  const checks = [];
+  const client = new OllamaClient(ollamaUrl);
+  const bin = await which("ollama");
+  checks.push({ name: "ollama binary", ok: bin !== null, detail: bin ?? "not on PATH" });
+  const version = await client.version();
+  checks.push({
+    name: "ollama server",
+    ok: version !== null,
+    detail: version ? `v${version} at ${ollamaUrl}` : `not reachable at ${ollamaUrl}`
+  });
+  if (version) {
+    const cachePath = releaseCachePath(cacheDir());
+    const latest = await latestOllamaVersion({
+      fetchImpl: (i, o) => fetch(i, o),
+      readCache: () => readJsonOr(cachePath, null),
+      writeCache: (c) => writeJson(cachePath, c),
+      now: () => Date.now()
+    });
+    if (latest) {
+      const outdated = isOutdated(version, latest);
+      checks.push({
+        name: "ollama version",
+        ok: !outdated,
+        warn: true,
+        detail: outdated ? `latest is ${latest}` : `up to date (${latest})`
+      });
+    } else {
+      checks.push({
+        name: "ollama version",
+        ok: true,
+        warn: true,
+        detail: "latest release unknown (offline)"
+      });
+    }
+  }
+  const manifest = await readManifest();
+  checks.push({
+    name: "install manifest",
+    ok: manifest.installs.length > 0,
+    detail: manifest.installs.length > 0 ? `${manifest.installs.length} install(s) in ${contractTilde(manifestPath())}` : "no installs recorded \u2014 run `lex init`"
+  });
+  const localModels = version ? await client.list().then((l) => l.map((m) => m.name)).catch(() => []) : [];
+  for (const rec of manifest.installs) {
+    const label = `${rec.agent}/${rec.scope}`;
+    const ownsRoot = rec.owned.includes(rec.root);
+    if (ownsRoot) {
+      const files = [
+        "core/PIPELINE.md",
+        "core/executor-system-prompt.md",
+        "runtime/run_executor.mjs",
+        "runtime/check_local.mjs",
+        "runtime/config.json"
+      ];
+      const missing = [];
+      for (const f of files) if (!await exists(join5(rec.root, f))) missing.push(f);
+      checks.push({
+        name: `${label} files`,
+        ok: missing.length === 0,
+        detail: missing.length === 0 ? contractTilde(rec.root) : `missing ${missing.join(", ")} in ${contractTilde(rec.root)}`
+      });
+      const cfg = await readJsonOr(rec.configPath, {});
+      const model = cfg.model ?? "(none)";
+      const pulled = localModels.includes(model) || localModels.includes(`${model}:latest`);
+      checks.push({
+        name: `${label} model`,
+        ok: version === null ? false : pulled,
+        detail: version === null ? `${model} (server down, cannot check)` : pulled ? `${model} pulled` : `${model} not pulled \u2014 run: ollama pull ${model}`
+      });
+    }
+    for (const o of rec.owned.filter((p2) => p2 !== rec.root)) {
+      checks.push({ name: `${label} adapter`, ok: await exists(o), detail: contractTilde(o) });
+    }
+    for (const m of rec.marked) {
+      const text3 = await import("fs/promises").then((fs) => fs.readFile(m, "utf8")).catch(() => "");
+      checks.push({
+        name: `${label} block`,
+        ok: text3.includes("<!-- lex:start -->"),
+        detail: contractTilde(m)
+      });
+    }
+  }
+  return checks;
+}
+async function runDoctor(opts) {
+  configureUi({ json: opts.json });
+  const checks = await collectDoctorChecks(opts.ollamaUrl);
+  const failures = checks.filter((c) => !c.ok && !c.warn);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify({ ok: failures.length === 0, checks }, null, 2)}
+`);
+    return failures.length === 0 ? 0 : 1;
+  }
+  intro2("lex doctor");
+  const rows = checks.map((c) => [
+    c.name,
+    `${c.ok ? pc.green("ok  ") : c.warn ? pc.yellow("warn") : pc.red("FAIL")}  ${c.detail}`
+  ]);
+  table(rows);
+  outro2(
+    failures.length === 0 ? pc.green("All checks passed.") : pc.red(`${failures.length} check(s) failed.`)
+  );
+  return failures.length === 0 ? 0 : 1;
+}
+
+// src/agents/detect.ts
+import { join as join6 } from "path";
+function pathProbe(cmd) {
+  return { label: `${cmd} on PATH`, check: async (d) => await d.which(cmd) !== null };
+}
+function dirProbe(rel) {
+  return { label: `~/${rel} exists`, check: async (d) => d.exists(join6(d.home, rel)) };
+}
+function appProbe(platform, label, path) {
+  return {
+    label,
+    check: async (d) => d.platform === platform && d.exists(path(d))
+  };
+}
+var probes = {
+  claude: [pathProbe("claude"), dirProbe(".claude")],
+  codex: [pathProbe("codex"), dirProbe(".codex")],
+  cursor: [
+    pathProbe("cursor"),
+    dirProbe(".cursor"),
+    appProbe("darwin", "Cursor.app installed", () => "/Applications/Cursor.app"),
+    appProbe(
+      "win32",
+      "Cursor installed",
+      (d) => join6(d.env.LOCALAPPDATA ?? "", "Programs", "cursor")
+    )
+  ],
+  windsurf: [
+    pathProbe("windsurf"),
+    dirProbe(".codeium/windsurf"),
+    appProbe("darwin", "Windsurf.app installed", () => "/Applications/Windsurf.app"),
+    appProbe(
+      "win32",
+      "Windsurf installed",
+      (d) => join6(d.env.LOCALAPPDATA ?? "", "Programs", "Windsurf")
+    )
+  ]
+};
+async function detectAgents(deps) {
+  const out = [];
+  for (const id of allAgents) {
+    const evidence = [];
+    for (const p2 of probes[id]) {
+      if (await p2.check(deps).catch(() => false)) evidence.push(p2.label);
+    }
+    out.push({ id, name: agentNames[id], detected: evidence.length > 0, evidence });
+  }
+  return out;
+}
+
+// src/steps/agents.ts
+init_fs();
+async function stepAgents(ctx) {
+  header(
+    "4/6",
+    "Agents",
+    "Which AI coding agents should learn the pipeline. Detected ones are preselected."
+  );
+  const platform = process.platform === "darwin" || process.platform === "win32" ? process.platform : "linux";
+  ctx.detections = await detectAgents({ which, exists, home: home(), platform, env: process.env });
+  const detected = ctx.detections.filter((d) => d.detected);
+  for (const d of ctx.detections) {
+    if (d.detected) success(`${d.name}: ${d.evidence.join(", ")}`);
+    else message(pc.dim(`${d.name}: not detected`));
+  }
+  if (ctx.opts.agents && ctx.opts.agents.length > 0) {
+    ctx.agents = ctx.opts.agents;
+  } else {
+    const initial = detected.map((d) => d.id);
+    ctx.agents = await multiselect2(
+      "Install the skill for",
+      allAgents.map((id) => ({
+        value: id,
+        label: agentNames[id],
+        hint: ctx.detections.find((d) => d.id === id)?.detected ? "detected" : "not detected \u2014 install anyway"
+      })),
+      initial,
+      false
+    );
+  }
+  if (ctx.agents.length === 0) {
+    warn(
+      "No agents selected. Nothing will be installed; run `lex init --agents claude,codex` later."
+    );
+  }
+  const notDetected = ctx.agents.filter((a) => !ctx.detections.find((d) => d.id === a)?.detected);
+  if (notDetected.length > 0) {
+    warn(
+      `Installing for agents that are not detected yet: ${notDetected.map((a) => agentNames[a]).join(", ")}. The files will be ready when you install them.`
+    );
+  }
+  ctx.projectRoot = await findGitRoot(ctx.cwd);
+  const needsProject = ctx.agents.some((a) => a === "cursor" || a === "windsurf");
+  if (ctx.opts.project !== void 0) {
+    ctx.installProject = ctx.opts.project && ctx.projectRoot !== null;
+    if (ctx.opts.project && !ctx.projectRoot) {
+      warn(
+        "--project given but the current directory is not inside a git repository; skipping project-level files."
+      );
+    }
+  } else if (ctx.projectRoot && ctx.agents.length > 0) {
+    ctx.installProject = await confirm2(
+      `Also install project-level files into ${ctx.projectRoot}? (${needsProject ? "required for Cursor/Windsurf rules; " : ""}Claude gets a repo-local copy of the skill)`,
+      needsProject
+    );
+  } else {
+    ctx.installProject = false;
+    if (needsProject) {
+      warn(
+        "Cursor/Windsurf rules are per project. Run `lex init --agents cursor --project` inside a repository to add the rule file there."
+      );
+    }
+  }
+}
+
+// src/hardware/detect.ts
+import { join as join7, resolve as resolve2, sep as sep2 } from "path";
+import si from "systeminformation";
+var defaultDeps = () => ({
+  cpu: () => si.cpu(),
+  mem: () => si.mem(),
+  graphics: () => si.graphics(),
+  fsSize: () => si.fsSize(),
+  platform: process.platform,
+  arch: process.arch,
+  env: process.env,
+  homedir: process.env.HOME ?? process.env.USERPROFILE ?? ""
+});
+var GB = 1024 ** 3;
+var round1 = (n) => Math.round(n * 10) / 10;
+function toPlatform(p2) {
+  if (p2 === "darwin" || p2 === "win32") return p2;
+  return "linux";
+}
+function ollamaModelsDir(env, homedir2) {
+  if (env.OLLAMA_MODELS) return env.OLLAMA_MODELS;
+  return join7(homedir2, ".ollama", "models");
+}
+function classifyGpu(controllers, platform, arch) {
+  if (platform === "darwin" && arch === "arm64") {
+    const apple = controllers.find((c) => /apple/i.test(`${c.vendor} ${c.model}`));
+    return { kind: "apple", model: apple?.model || "Apple Silicon (unified memory)", vramGB: null };
+  }
+  let best = { kind: "none", model: "", vramGB: null };
+  const rank = { nvidia: 4, amd: 3, apple: 2, intel: 1, none: 0 };
+  for (const c of controllers) {
+    const text3 = `${c.vendor} ${c.model}`;
+    let kind = "none";
+    if (/nvidia/i.test(text3)) kind = "nvidia";
+    else if (/\b(amd|ati|radeon)\b/i.test(text3)) kind = "amd";
+    else if (/intel/i.test(text3)) kind = "intel";
+    else if (/apple/i.test(text3)) kind = "apple";
+    if (kind === "none") continue;
+    const mb = c.memoryTotal ?? c.vram ?? null;
+    const vramGB = mb === null ? null : round1(mb / 1024);
+    const better = rank[kind] > rank[best.kind] || rank[kind] === rank[best.kind] && (vramGB ?? 0) > (best.vramGB ?? 0);
+    if (better) best = { kind, model: c.model || c.vendor, vramGB };
+  }
+  return best;
+}
+function pickVolume(volumes, dir, platform) {
+  const norm = (p2) => {
+    let s = resolve2(p2);
+    if (platform === "win32") s = s.toLowerCase();
+    return s.endsWith(sep2) ? s : s + sep2;
+  };
+  const target = norm(dir);
+  let best;
+  let bestLen = -1;
+  for (const v of volumes) {
+    if (!v.mount) continue;
+    const m = norm(v.mount);
+    if (target.startsWith(m) && m.length > bestLen) {
+      best = v;
+      bestLen = m.length;
+    }
+  }
+  return best;
+}
+async function detectHardware(deps = defaultDeps()) {
+  const [cpu, mem, gfx, volumes] = await Promise.all([
+    deps.cpu().catch(() => ({ manufacturer: "", brand: "unknown", cores: 1, physicalCores: 1 })),
+    deps.mem().catch(() => ({ total: 0, available: 0, free: 0 })),
+    deps.graphics().catch(() => ({ controllers: [] })),
+    deps.fsSize().catch(() => [])
+  ]);
+  const modelsDir = ollamaModelsDir(deps.env, deps.homedir);
+  const vol = pickVolume(volumes, modelsDir, deps.platform) ?? pickVolume(volumes, deps.homedir, deps.platform);
+  const physical = cpu.physicalCores > 0 ? cpu.physicalCores : cpu.cores;
+  const cpuModel = [cpu.manufacturer, cpu.brand].filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+  return {
+    platform: toPlatform(deps.platform),
+    arch: deps.arch,
+    cpuModel: cpuModel || "unknown CPU",
+    physicalCores: physical,
+    logicalCores: cpu.cores,
+    totalRamGB: round1(mem.total / GB),
+    freeRamGB: round1((mem.available || mem.free) / GB),
+    gpu: classifyGpu(gfx.controllers, deps.platform, deps.arch),
+    freeDiskGB: round1((vol?.available ?? 0) / GB),
+    modelsDir
+  };
+}
+
+// src/models/catalog.ts
+var lastVerified = "2026-09-06";
+var catalog = [
+  {
+    tag: "qwen3.5:2b",
+    family: "qwen3.5",
+    params: "2B dense",
+    sizeGB: 2.7,
+    contextK: 256,
+    notes: "Smallest usable executor; keep packets short and single-file."
+  },
+  {
+    tag: "gemma4:e2b",
+    family: "gemma4",
+    params: "2B effective (per-layer embeddings)",
+    sizeGB: 7.2,
+    contextK: 128,
+    notes: "Fast on CPU; larger download than its active size suggests."
+  },
+  {
+    tag: "qwen3.5:4b",
+    family: "qwen3.5",
+    params: "4B dense",
+    sizeGB: 3.4,
+    contextK: 256,
+    notes: "Light and fast; good for small, well-specified tasks."
+  },
+  {
+    tag: "gemma4:e4b",
+    family: "gemma4",
+    params: "4B effective (per-layer embeddings)",
+    sizeGB: 9.6,
+    contextK: 128,
+    notes: "Solid instruction following; heavier download than qwen3.5:4b."
+  },
+  {
+    tag: "qwen3.5:9b",
+    family: "qwen3.5",
+    params: "9B dense",
+    sizeGB: 6.6,
+    contextK: 256,
+    notes: "Best code quality that fits on a 16 GB machine."
+  },
+  {
+    tag: "qwen3.5:9b-mlx",
+    family: "qwen3.5",
+    params: "9B dense, MLX build",
+    sizeGB: 8.9,
+    contextK: 256,
+    notes: "Apple Silicon only; faster than the GGUF build, needs ~2 GB more memory.",
+    appleOnly: true
+  },
+  {
+    tag: "gemma4:12b",
+    family: "gemma4",
+    params: "12B dense",
+    sizeGB: 7.6,
+    contextK: 256,
+    notes: "Dense 12B; a good middle ground when 9B is not enough."
+  },
+  {
+    tag: "devstral",
+    family: "devstral",
+    params: "24B dense (Mistral, agentic coding)",
+    sizeGB: 14,
+    contextK: 128,
+    notes: "Purpose-built for coding; older but well-tested."
+  },
+  {
+    tag: "gemma4:26b",
+    family: "gemma4",
+    params: "26B MoE (4B active)",
+    sizeGB: 19,
+    contextK: 256,
+    notes: "Strong coding; MoE is fast per token but the whole 26B must fit in memory."
+  },
+  {
+    tag: "qwen3.6:27b-coding",
+    family: "qwen3.6",
+    params: "27B dense, coding tune",
+    sizeGB: 18,
+    contextK: 256,
+    notes: "Dense coding tune; slower per token than the 35B MoE but very capable."
+  },
+  {
+    tag: "gemma4:31b",
+    family: "gemma4",
+    params: "31B dense",
+    sizeGB: 20,
+    contextK: 256,
+    notes: "Largest Gemma that fits on a 48 GB machine with room for context."
+  },
+  {
+    tag: "qwen3.6:35b-a3b",
+    family: "qwen3.6",
+    params: "35B MoE (3B active)",
+    sizeGB: 23,
+    contextK: 256,
+    notes: "Frontier-adjacent local coding; fast per token thanks to 3B active."
+  },
+  {
+    tag: "qwen3.6:35b-a3b-coding",
+    family: "qwen3.6",
+    params: "35B MoE (3B active), coding tune",
+    sizeGB: 23,
+    contextK: 256,
+    notes: "Same footprint as qwen3.6:35b-a3b with a coding-specific fine-tune."
+  }
+];
+var tiers = [
+  {
+    minGB: 0,
+    maxGB: 6,
+    label: "< 6 GB",
+    recommended: "qwen3.5:2b",
+    alsoOffer: ["gemma4:e2b"],
+    reason: "Very tight; short packets only"
+  },
+  {
+    minGB: 6,
+    maxGB: 10,
+    label: "6\u201310 GB",
+    recommended: "qwen3.5:4b",
+    alsoOffer: ["gemma4:e4b"],
+    reason: "Light and fast; good for small tasks"
+  },
+  {
+    minGB: 10,
+    maxGB: 14,
+    label: "10\u201314 GB",
+    recommended: "qwen3.5:9b",
+    alsoOffer: ["gemma4:e4b", "qwen3.5:4b"],
+    reason: "Best code quality that fits"
+  },
+  {
+    minGB: 14,
+    maxGB: 22,
+    label: "14\u201322 GB",
+    recommended: "qwen3.5:9b",
+    alsoOffer: ["gemma4:e4b", "qwen3.5:9b-mlx"],
+    reason: "9B at Q4 fits with headroom"
+  },
+  {
+    minGB: 22,
+    maxGB: 30,
+    label: "22\u201330 GB",
+    recommended: "gemma4:26b",
+    alsoOffer: ["qwen3.5:9b", "devstral"],
+    reason: "MoE 26B fits; strong coding"
+  },
+  {
+    minGB: 30,
+    maxGB: 48,
+    label: "30\u201348 GB",
+    recommended: "qwen3.6:35b-a3b",
+    alsoOffer: ["gemma4:26b", "gemma4:31b"],
+    reason: "Frontier-adjacent local coding"
+  },
+  {
+    minGB: 48,
+    maxGB: Number.POSITIVE_INFINITY,
+    label: "\u2265 48 GB",
+    recommended: "qwen3.6:35b-a3b",
+    alsoOffer: ["gemma4:31b", "qwen3.6:35b-a3b-coding", "qwen3.6:27b-coding"],
+    reason: "Room for big context"
+  }
+];
+var diskSafetyFactor = 1.5;
+var minCpuOnlyCores = 4;
+var appleUnifiedMemoryShare = 0.7;
+var cpuOnlyRamShare = 0.5;
+var minDiscreteVramGB = 4;
+function findModel(tag) {
+  return catalog.find((m) => m.tag === tag);
+}
+
+// src/models/recommend.ts
+function round12(n) {
+  return Math.round(n * 10) / 10;
+}
+function isAppleSilicon(hw) {
+  return hw.platform === "darwin" && hw.arch === "arm64";
+}
+function effectiveMemory(hw) {
+  if (isAppleSilicon(hw) || hw.gpu.kind === "apple") {
+    return {
+      gb: round12(hw.totalRamGB * appleUnifiedMemoryShare),
+      rule: `Apple Silicon: ${Math.round(appleUnifiedMemoryShare * 100)}% of ${round12(hw.totalRamGB)} GB unified memory`
+    };
+  }
+  const vram = hw.gpu.vramGB ?? 0;
+  if ((hw.gpu.kind === "nvidia" || hw.gpu.kind === "amd") && vram >= minDiscreteVramGB) {
+    const vendor = hw.gpu.kind === "nvidia" ? "NVIDIA" : "AMD";
+    return {
+      gb: round12(vram),
+      rule: `${vendor} GPU: ${round12(vram)} GB VRAM (${hw.gpu.model})`
+    };
+  }
+  return {
+    gb: round12(hw.totalRamGB * cpuOnlyRamShare),
+    rule: `CPU only: ${Math.round(cpuOnlyRamShare * 100)}% of ${round12(hw.totalRamGB)} GB RAM`
+  };
+}
+function tierFor(effectiveGB) {
+  const found = tiers.find((t) => effectiveGB >= t.minGB && effectiveGB < t.maxGB);
+  return found ?? tiers[0];
+}
+function tierIndex(tier) {
+  return tiers.indexOf(tier);
+}
+function stepDown(tier) {
+  const i = tierIndex(tier);
+  return i > 0 ? tiers[i - 1] : void 0;
+}
+function diskNeededGB(model) {
+  return round12(model.sizeGB * diskSafetyFactor);
+}
+function isCpuOnly(hw) {
+  if (isAppleSilicon(hw) || hw.gpu.kind === "apple") return false;
+  const vram = hw.gpu.vramGB ?? 0;
+  return !((hw.gpu.kind === "nvidia" || hw.gpu.kind === "amd") && vram >= minDiscreteVramGB);
+}
+function buildRecommendation(hw, opts = {}) {
+  const mem = effectiveMemory(hw);
+  const naturalTier = tierFor(mem.gb);
+  let tier = naturalTier;
+  const adjustments = [];
+  if (isCpuOnly(hw) && hw.physicalCores < minCpuOnlyCores) {
+    const from = tier;
+    let lower = stepDown(tier);
+    while (lower && lower.recommended === from.recommended) lower = stepDown(lower);
+    if (lower) {
+      adjustments.push(
+        `Stepped down from ${from.recommended} to ${lower.recommended}: only ${hw.physicalCores} physical cores on a CPU-only machine; a larger model would be too slow.`
+      );
+      tier = lower;
+    }
+  }
+  for (; ; ) {
+    const model = findModel(tier.recommended);
+    if (!model) break;
+    if (diskNeededGB(model) <= hw.freeDiskGB) break;
+    const lower = stepDown(tier);
+    if (!lower) {
+      adjustments.push(
+        `${tier.recommended} needs ${diskNeededGB(model)} GB free disk (download \xD7 ${diskSafetyFactor}) and only ${round12(hw.freeDiskGB)} GB is free. Nothing smaller is in the catalog; free some space before pulling.`
+      );
+      break;
+    }
+    adjustments.push(
+      `Stepped down from ${tier.recommended} to ${lower.recommended}: ${tier.recommended} needs ${diskNeededGB(model)} GB free disk and only ${round12(hw.freeDiskGB)} GB is free.`
+    );
+    tier = lower;
+  }
+  const apple = isAppleSilicon(hw);
+  const seen = /* @__PURE__ */ new Set();
+  const list = [];
+  const push = (tag, reason, recommended) => {
+    const model = findModel(tag);
+    if (!model || seen.has(tag)) return;
+    if (model.appleOnly && !apple) return;
+    seen.add(tag);
+    const needed = diskNeededGB(model);
+    const fitsDisk = needed <= hw.freeDiskGB;
+    const fitsMemory = model.sizeGB <= mem.gb;
+    const warnings = [];
+    if (!fitsDisk) {
+      warnings.push(`Needs ${needed} GB free disk; ${round12(hw.freeDiskGB)} GB available.`);
+    }
+    if (!fitsMemory) {
+      warnings.push(
+        `Download (${model.sizeGB} GB) is larger than effective memory (${mem.gb} GB); expect swapping and very slow output.`
+      );
+    }
+    list.push({
+      tag,
+      sizeGB: model.sizeGB,
+      diskNeededGB: needed,
+      fitsDisk,
+      fitsMemory,
+      recommended,
+      rank: list.length,
+      reason,
+      warnings,
+      model
+    });
+  };
+  push(tier.recommended, tier.reason, true);
+  for (const alt of tier.alsoOffer) {
+    const m = findModel(alt);
+    push(alt, m?.notes ?? "Alternative for this tier", false);
+  }
+  const rest = catalog.filter((m) => !seen.has(m.tag));
+  const fitting = rest.filter((m) => m.sizeGB <= mem.gb).sort((a, b) => b.sizeGB - a.sizeGB);
+  for (const m of fitting) push(m.tag, m.notes, false);
+  if (opts.includeAll) {
+    const tooBig = rest.filter((m) => m.sizeGB > mem.gb).sort((a, b) => a.sizeGB - b.sizeGB);
+    for (const m of tooBig) push(m.tag, `${m.notes} (does not fit in ${mem.gb} GB)`, false);
+  }
+  return { effectiveMemory: mem, tier, naturalTier, adjustments, list };
+}
+
+// src/steps/hardware.ts
+var gb = (n) => `${Math.round(n * 10) / 10} GB`;
+function hardwareRows(hw) {
+  const gpu = hw.gpu.kind === "apple" ? "Apple Silicon (unified memory)" : hw.gpu.kind === "none" ? "none detected" : `${hw.gpu.model}${hw.gpu.vramGB !== null ? ` (${gb(hw.gpu.vramGB)} VRAM)` : ""}`;
+  return [
+    ["OS", `${hw.platform} (${hw.arch})`],
+    ["CPU", `${hw.cpuModel}, ${hw.physicalCores} cores (${hw.logicalCores} threads)`],
+    ["RAM", `${gb(hw.totalRamGB)} total, ${gb(hw.freeRamGB)} free`],
+    ["GPU", gpu],
+    ["Free disk", `${gb(hw.freeDiskGB)} on the volume holding ${hw.modelsDir}`]
+  ];
+}
+async function stepHardware(ctx) {
+  header(
+    "2/6",
+    "Hardware",
+    "What this machine can run. Effective memory decides the model tier."
+  );
+  const sp = spinner2();
+  sp.start("Detecting CPU, memory, GPU, and disk\u2026");
+  const hw = await detectHardware();
+  sp.stop("Hardware detected.");
+  ctx.hw = hw;
+  table(hardwareRows(hw));
+  const report = buildRecommendation(hw);
+  ctx.report = report;
+  info(
+    `Effective memory for models: ${pc.bold(gb(report.effectiveMemory.gb))} (${report.effectiveMemory.rule}) \u2192 tier ${report.tier.label}`
+  );
+  for (const a of report.adjustments) warn(a);
+  const top = report.list[0];
+  if (top) success(`Recommended: ${code(top.tag)} (~${top.sizeGB} GB) \u2014 ${top.reason}`);
+}
+
+// src/ollama/progress.ts
+var PullTracker = class {
+  layers = /* @__PURE__ */ new Map();
+  status = "starting";
+  startedAt;
+  now;
+  constructor(now = () => Date.now()) {
+    this.now = now;
+    this.startedAt = now();
+  }
+  update(e) {
+    if (e.status) this.status = e.status;
+    if (e.digest && typeof e.total === "number") {
+      this.layers.set(e.digest, { total: e.total, completed: e.completed ?? 0 });
+    }
+    return this.snapshot();
+  }
+  snapshot() {
+    let total = 0;
+    let completed = 0;
+    for (const l of this.layers.values()) {
+      total += l.total;
+      completed += l.completed;
+    }
+    const elapsedSec = Math.max(1e-3, (this.now() - this.startedAt) / 1e3);
+    return {
+      status: this.status,
+      completedBytes: completed,
+      totalBytes: total,
+      percent: total > 0 ? Math.min(100, Math.floor(completed / total * 100)) : null,
+      bytesPerSec: completed > 0 ? completed / elapsedSec : null
+    };
+  }
+};
+function formatBytes(n) {
+  if (n >= 1024 ** 3) return `${(n / 1024 ** 3).toFixed(1)} GB`;
+  if (n >= 1024 ** 2) return `${Math.round(n / 1024 ** 2)} MB`;
+  if (n >= 1024) return `${Math.round(n / 1024)} KB`;
+  return `${n} B`;
+}
+function formatPullLine(tag, s) {
+  if (s.percent === null) return `Pulling ${tag}: ${s.status}`;
+  const speed = s.bytesPerSec ? `  ${formatBytes(s.bytesPerSec)}/s` : "";
+  return `Pulling ${tag}: ${s.percent}%  ${formatBytes(s.completedBytes)} / ${formatBytes(s.totalBytes)}${speed}`;
+}
+
+// src/steps/model.ts
+var CUSTOM = "__custom__";
+function isValidTag(tag) {
+  return /^[a-zA-Z0-9._\-/]+(:[a-zA-Z0-9._-]+)?$/.test(tag);
+}
+function choiceFor(r) {
+  const flags = [
+    r.recommended ? "recommended" : null,
+    !r.fitsDisk ? "needs more disk" : null,
+    !r.fitsMemory ? "may swap" : null
+  ].filter(Boolean);
+  const hint = `~${r.sizeGB} GB \xB7 ${r.reason}${flags.length ? ` \xB7 ${flags.join(", ")}` : ""}`;
+  return { value: r.tag, label: r.recommended ? `${r.tag}  \u2605` : r.tag, hint };
+}
+async function chooseModel(ctx) {
+  if (ctx.opts.model) {
+    if (!isValidTag(ctx.opts.model))
+      throw new Error(`"${ctx.opts.model}" does not look like an Ollama tag.`);
+    return ctx.opts.model;
+  }
+  const list = ctx.report?.list ?? [];
+  const top = list.find((r) => r.recommended)?.tag ?? "qwen3.5:9b";
+  if (nonInteractive()) return top;
+  const picked = await select2(
+    "Executor model",
+    [
+      ...list.map(choiceFor),
+      { value: CUSTOM, label: "Enter a custom tag\u2026", hint: "any tag from ollama.com/library" }
+    ],
+    top
+  );
+  if (picked !== CUSTOM) return picked;
+  for (; ; ) {
+    const tag = await text2("Ollama tag", "e.g. qwen3.5:9b-q8_0", top);
+    if (isValidTag(tag)) return tag;
+    warn(`"${tag}" does not look like a valid tag.`);
+  }
+}
+async function pullModel(ctx, tag) {
+  const sp = spinner2();
+  const tracker = new PullTracker();
+  let lastPercent = -1;
+  sp.start(`Pulling ${tag}\u2026`);
+  try {
+    await ctx.client.pull(tag, (e) => {
+      const s = tracker.update(e);
+      if (s.percent !== lastPercent || s.percent === null) {
+        lastPercent = s.percent ?? -1;
+        sp.message(formatPullLine(tag, s));
+      }
+    });
+    sp.stop(`Pulled ${tag}.`);
+    return true;
+  } catch (err) {
+    sp.error(`Pull failed: ${err.message}`);
+    return false;
+  }
+}
+async function warmupModel(ctx, tag) {
+  const sp = spinner2();
+  sp.start(`Loading ${tag} and measuring speed (first load can take 10\u201330 s)\u2026`);
+  try {
+    const w = await ctx.client.warmup(tag);
+    ctx.warmup = w;
+    const speed = w.tokensPerSec !== null ? `${w.tokensPerSec} tok/s` : "speed unknown";
+    sp.stop(
+      `${tag} ready: ${pc.bold(speed)} (load ${Math.round(w.loadDurationMs / 100) / 10} s, ${w.evalCount} tokens generated)`
+    );
+  } catch (err) {
+    ctx.warmup = null;
+    sp.error(`Warm-up failed: ${err.message}`);
+    ctx.warnings.push(`Warm-up request failed for ${tag}; the model may not have loaded.`);
+  }
+}
+async function stepModel(ctx) {
+  header(
+    "3/6",
+    "Model",
+    "Pick the executor model, pull it, and measure real tokens/sec on this machine."
+  );
+  const tag = await chooseModel(ctx);
+  ctx.model = tag;
+  const known = findModel(tag);
+  const rec = ctx.report?.list.find((r) => r.tag === tag);
+  if (known) ctx.modelSizeGB = known.sizeGB;
+  for (const w of rec?.warnings ?? []) warn(w);
+  const up = await ctx.client.isUp();
+  if (!up) {
+    warn(
+      `Ollama is not reachable at ${ctx.client.baseUrl}; skipping pull and warm-up. Config will still point at ${tag}.`
+    );
+    ctx.warnings.push(
+      `Model ${tag} was not pulled because Ollama was unreachable. Run: ollama pull ${tag}`
+    );
+    ctx.pulled = false;
+    return;
+  }
+  const have = await ctx.client.hasModel(tag).catch(() => false);
+  if (have) {
+    success(`${tag} is already pulled.`);
+    ctx.pulled = true;
+  } else if (ctx.opts.skipPull) {
+    warn(`--skip-pull: not pulling ${tag}. Run: ollama pull ${tag}`);
+    ctx.warnings.push(`Model ${tag} not pulled (--skip-pull).`);
+    ctx.pulled = false;
+  } else {
+    const size = known ? `about ${known.sizeGB} GB` : "size unknown (not in the catalog)";
+    info(`Download: ${size}. Downloads over 100 MB always ask first unless --yes was given.`);
+    const ok = await confirm2(`Pull ${tag} now?`, true);
+    if (!ok) {
+      ctx.warnings.push(`Model ${tag} not pulled. Run: ollama pull ${tag}`);
+      ctx.pulled = false;
+    } else {
+      ctx.pulled = await pullModel(ctx, tag);
+      if (!ctx.pulled)
+        ctx.warnings.push(
+          `Pull of ${tag} failed. Check the tag on ollama.com/library and retry: ollama pull ${tag}`
+        );
+    }
+  }
+  if (ctx.pulled) await warmupModel(ctx, tag);
+}
+
+// src/steps/ollama.ts
+import { join as join9 } from "path";
+
+// src/ollama/install.ts
+import { join as join8 } from "path";
+var OLLAMA_DOWNLOAD_URL = "https://ollama.com/download";
+var OLLAMA_LINUX_SCRIPT = "https://ollama.com/install.sh";
+function planOllamaInstall(env) {
+  switch (env.platform) {
+    case "darwin":
+      if (env.hasBrew) {
+        return {
+          kind: "command",
+          file: "brew",
+          args: ["install", "ollama"],
+          display: displayCommand("brew", ["install", "ollama"]),
+          explanation: "Installs the Ollama CLI and server with Homebrew into your user prefix. No sudo. Later you can run `brew upgrade ollama`.",
+          privileged: false
+        };
+      }
+      return {
+        kind: "download",
+        url: OLLAMA_DOWNLOAD_URL,
+        explanation: "Homebrew is not installed, so download the macOS app from ollama.com, drag it to Applications, open it once, then re-run lex."
+      };
+    case "linux":
+      return {
+        kind: "command",
+        file: "sh",
+        args: ["-c", `curl -fsSL ${OLLAMA_LINUX_SCRIPT} | sh`],
+        display: `curl -fsSL ${OLLAMA_LINUX_SCRIPT} | sh`,
+        explanation: "Runs Ollama's official install script. It downloads the binary to /usr/local, creates an `ollama` system user and a systemd service, and installs GPU drivers hooks if it finds NVIDIA/AMD hardware. It will ask for sudo.",
+        privileged: true
+      };
+    case "win32":
+      if (env.hasWinget) {
+        return {
+          kind: "command",
+          file: "winget",
+          args: [
+            "install",
+            "--id",
+            "Ollama.Ollama",
+            "-e",
+            "--accept-source-agreements",
+            "--accept-package-agreements"
+          ],
+          display: displayCommand("winget", ["install", "--id", "Ollama.Ollama", "-e"]),
+          explanation: "Installs Ollama for Windows with winget (per-user install, no admin needed). It also installs the tray app that keeps the server running.",
+          privileged: false
+        };
+      }
+      return {
+        kind: "download",
+        url: OLLAMA_DOWNLOAD_URL,
+        explanation: "winget is not available, so download OllamaSetup.exe from ollama.com, run it, then re-run lex."
+      };
+  }
+}
+function planServerStart(platform, opts = {}) {
+  if (platform === "darwin" && opts.macAppPresent) {
+    return { file: "open", args: ["-a", "Ollama"], display: "open -a Ollama", usesApp: true };
+  }
+  if (platform === "win32" && opts.winAppPath) {
+    return { file: opts.winAppPath, args: [], display: `"${opts.winAppPath}"`, usesApp: true };
+  }
+  return { file: "ollama", args: ["serve"], display: "ollama serve  (detached)", usesApp: false };
+}
+function appCandidates(platform, env) {
+  if (platform === "darwin")
+    return ["/Applications/Ollama.app", join8(env.HOME ?? "", "Applications", "Ollama.app")];
+  if (platform === "win32") {
+    const local = env.LOCALAPPDATA ?? "";
+    return [join8(local, "Programs", "Ollama", "ollama app.exe")];
+  }
+  return [];
+}
+
+// src/steps/ollama.ts
+init_fs();
+init_state();
+function platformOf() {
+  return process.platform === "darwin" || process.platform === "win32" ? process.platform : "linux";
+}
+async function fetchLatest() {
+  const cachePath = releaseCachePath(cacheDir());
+  return latestOllamaVersion({
+    fetchImpl: (i, o) => fetch(i, o),
+    readCache: () => readJsonOr(cachePath, null),
+    writeCache: (c) => writeJson(cachePath, c),
+    now: () => Date.now()
+  });
+}
+function upgradePlan(plan) {
+  if (plan.kind !== "command") return plan;
+  if (plan.file === "brew") {
+    return {
+      ...plan,
+      args: ["upgrade", "ollama"],
+      display: displayCommand("brew", ["upgrade", "ollama"])
+    };
+  }
+  if (plan.file === "winget") {
+    const args = [
+      "upgrade",
+      "--id",
+      "Ollama.Ollama",
+      "-e",
+      "--accept-source-agreements",
+      "--accept-package-agreements"
+    ];
+    return {
+      ...plan,
+      args,
+      display: displayCommand("winget", ["upgrade", "--id", "Ollama.Ollama", "-e"])
+    };
+  }
+  return plan;
+}
+async function runPlan(ctx, plan, verb) {
+  if (plan.kind === "download") {
+    warn(plan.explanation);
+    info(`Opening ${plan.url}`);
+    await openUrl(plan.url);
+    ctx.warnings.push(`Ollama must be ${verb}ed manually from ${plan.url}; re-run lex afterwards.`);
+    return false;
+  }
+  note2(`${code(plan.display)}
+
+${plan.explanation}`, `Command to ${verb} Ollama`);
+  const nonInteractive2 = nonInteractive();
+  if (nonInteractive2 && !ctx.opts.allowInstall) {
+    warn(
+      `Not running ${verb} without confirmation (non-interactive). Pass --allow-install to permit it.`
+    );
+    ctx.warnings.push(`Ollama ${verb} skipped in non-interactive mode. Run: ${plan.display}`);
+    return false;
+  }
+  const ok = await confirm2(
+    `Run this now?${plan.privileged ? " (it will ask for sudo)" : ""}`,
+    true
+  );
+  if (!ok) {
+    ctx.warnings.push(`Ollama ${verb} declined. Run it yourself: ${plan.display}`);
+    return false;
+  }
+  const sp = spinner2();
+  if (!ui.tty) sp.start(`Running: ${plan.display}`);
+  const result = await run(plan.file, plan.args, { inherit: true });
+  if (!result.ok) {
+    error(`${plan.display} exited with code ${result.exitCode ?? "?"}.`);
+    ctx.warnings.push(`Ollama ${verb} command failed (exit ${result.exitCode ?? "?"}).`);
+    return false;
+  }
+  success(`Ollama ${verb} command finished.`);
+  return true;
+}
+async function startServer(ctx) {
+  const platform = platformOf();
+  const env = process.env;
+  const candidates = appCandidates(platform, env);
+  let appPath = null;
+  for (const c of candidates) if (await exists(c)) appPath = c;
+  const plan = planServerStart(platform, {
+    macAppPresent: platform === "darwin" && appPath !== null,
+    winAppPath: platform === "win32" ? appPath : null
+  });
+  info(`Starting the server: ${code(plan.display)}`);
+  if (plan.usesApp && platform === "darwin") await run(plan.file, plan.args);
+  else spawnDetached(plan.file, plan.args);
+  const sp = spinner2();
+  sp.start("Waiting for Ollama to answer on the health endpoint\u2026");
+  const up = await ctx.client.waitUntilUp(3e4);
+  if (up) sp.stop("Ollama is running.");
+  else sp.error("Ollama did not respond within 30 s.");
+  return up;
+}
+async function stepOllama(ctx) {
+  header(
+    "1/6",
+    "Ollama",
+    "The local server that runs the executor model. Detect, install, start, and check the version."
+  );
+  if (ctx.opts.skipOllama) {
+    ctx.ollama.skipped = true;
+    warn(
+      "Skipping Ollama setup (--skip-ollama). Later steps will re-check the server and warn if it is down."
+    );
+  } else if (!nonInteractive()) {
+    const choice = await select2(
+      "Ollama setup",
+      [
+        { value: "run", label: "Detect and set up Ollama for me", hint: "recommended" },
+        { value: "skip", label: "Skip \u2014 I manage Ollama myself" }
+      ],
+      "run"
+    );
+    ctx.ollama.skipped = choice === "skip";
+  }
+  ctx.ollama.binary = await which("ollama");
+  ctx.ollama.version = await ctx.client.version();
+  if (ctx.ollama.skipped) {
+    if (ctx.ollama.version)
+      success(`Ollama ${ctx.ollama.version} is reachable at ${ctx.client.baseUrl}.`);
+    else
+      warn(
+        `Ollama is not reachable at ${ctx.client.baseUrl}. Model pull and verification will be skipped.`
+      );
+    return;
+  }
+  const platform = platformOf();
+  const env = {
+    platform,
+    hasBrew: await which("brew") !== null,
+    hasWinget: await which("winget") !== null
+  };
+  if (!ctx.ollama.binary && !ctx.ollama.version) {
+    warn("Ollama is not installed (not on PATH, server not responding).");
+    const installed = await runPlan(ctx, planOllamaInstall(env), "install");
+    if (!installed) return;
+    ctx.ollama.binary = await which("ollama");
+    ctx.ollama.version = await ctx.client.version();
+  } else if (ctx.ollama.binary && !ctx.ollama.version) {
+    info(
+      `Ollama binary found at ${ctx.ollama.binary}, but the server is not responding at ${ctx.client.baseUrl}.`
+    );
+  } else {
+    success(`Ollama ${ctx.ollama.version} is running at ${ctx.client.baseUrl}.`);
+  }
+  if (!ctx.ollama.version) {
+    const up = await startServer(ctx);
+    if (!up) {
+      ctx.warnings.push(
+        "Ollama server could not be started. Start it manually (open the Ollama app or run `ollama serve`)."
+      );
+      return;
+    }
+    ctx.ollama.version = await ctx.client.version();
+  }
+  ctx.ollama.latest = await fetchLatest();
+  if (ctx.ollama.latest && ctx.ollama.version) {
+    if (isOutdated(ctx.ollama.version, ctx.ollama.latest)) {
+      warn(`Ollama ${ctx.ollama.version} is installed; latest is ${ctx.ollama.latest}.`);
+      if (nonInteractive()) {
+        ctx.warnings.push(
+          `Ollama is outdated (${ctx.ollama.version} < ${ctx.ollama.latest}). Upgrade when convenient.`
+        );
+      } else {
+        const want = await confirm2("Upgrade Ollama now?", false);
+        if (want) {
+          const done = await runPlan(ctx, upgradePlan(planOllamaInstall(env)), "upgrade");
+          if (done) info("Restart the Ollama app/server to pick up the new version.");
+        }
+      }
+    } else {
+      info(`Ollama is up to date (latest release: ${ctx.ollama.latest}).`);
+    }
+  } else if (!ctx.ollama.latest) {
+    info(
+      "Could not check the latest Ollama release (offline or rate-limited); skipping the version check."
+    );
+  }
+  if (!process.env.OLLAMA_MODELS) {
+    const home2 = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const dir = join9(home2, ".ollama", "models");
+    if (!await exists(dir)) info(`Model store will be created at ${dir} on first pull.`);
+  }
+}
+
+// src/agents/install.ts
+init_fs();
+import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import { basename, dirname as dirname2, join as join11 } from "path";
+
+// src/util/markers.ts
+var START_MARKER = "<!-- lex:start -->";
+var END_MARKER = "<!-- lex:end -->";
+var defaultMarkers = { start: START_MARKER, end: END_MARKER };
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function blockRegex(m) {
+  return new RegExp(`${escapeRegExp(m.start)}[\\s\\S]*?${escapeRegExp(m.end)}\\n?`, "g");
+}
+function hasBlock(content, m = defaultMarkers) {
+  return content.includes(m.start) && content.includes(m.end);
+}
+function wrapBlock(body, m = defaultMarkers) {
+  const trimmed = body.replace(/\s+$/, "");
+  return `${m.start}
+${trimmed}
+${m.end}
+`;
+}
+function upsertBlock(content, body, m = defaultMarkers) {
+  const block = wrapBlock(body, m);
+  if (hasBlock(content, m)) {
+    return content.replace(blockRegex(m), block);
+  }
+  if (content.length === 0) return block;
+  const sep3 = content.endsWith("\n\n") ? "" : content.endsWith("\n") ? "\n" : "\n\n";
+  return `${content}${sep3}${block}`;
+}
+function removeBlock(content, m = defaultMarkers) {
+  if (!hasBlock(content, m)) return content;
+  const re = new RegExp(`\\n*${escapeRegExp(m.start)}[\\s\\S]*?${escapeRegExp(m.end)}\\n?`, "g");
+  let sawContentBefore = false;
+  const out = content.replace(re, (_whole, offset) => {
+    sawContentBefore = content.slice(0, offset).trim().length > 0;
+    return sawContentBefore ? "\n" : "";
+  });
+  return out;
+}
+
+// src/agents/paths.ts
+import { join as join10 } from "path";
+var SKILL_DIR_NAME = "local-executor-pipeline";
+function userTarget(agent, ctx) {
+  const h = ctx.home;
+  switch (agent) {
+    case "claude": {
+      const root = join10(h, ".claude", "skills", SKILL_DIR_NAME);
+      return {
+        agent,
+        scope: "user",
+        root,
+        adapters: [{ source: "claude-code/SKILL.md", dest: join10(root, "SKILL.md") }],
+        marked: [],
+        optional: [],
+        summary: "Claude Code user-level skill"
+      };
+    }
+    case "codex": {
+      const root = join10(h, ".codex", "local-executor");
+      return {
+        agent,
+        scope: "user",
+        root,
+        adapters: [],
+        marked: [{ source: "codex/AGENTS.block.md", dest: join10(h, ".codex", "AGENTS.md") }],
+        optional: [
+          {
+            ifDirExists: join10(h, ".codex", "skills"),
+            adapter: {
+              source: "codex/SKILL.md",
+              dest: join10(h, ".codex", "skills", SKILL_DIR_NAME, "SKILL.md")
+            }
+          }
+        ],
+        summary: "Codex CLI global instructions block + scripts"
+      };
+    }
+    case "cursor": {
+      const root = join10(h, ".cursor", "local-executor");
+      return {
+        agent,
+        scope: "user",
+        root,
+        adapters: [],
+        marked: [],
+        optional: [],
+        summary: "Cursor global scripts copy (rules are per project)"
+      };
+    }
+    case "windsurf": {
+      const root = join10(h, ".codeium", "windsurf", "local-executor");
+      return {
+        agent,
+        scope: "user",
+        root,
+        adapters: [],
+        marked: [],
+        optional: [],
+        summary: "Windsurf global scripts copy (rules are per project)"
+      };
+    }
+  }
+}
+function projectTarget(agent, ctx) {
+  if (!ctx.projectRoot) return null;
+  const p2 = ctx.projectRoot;
+  const user = userTarget(agent, ctx);
+  switch (agent) {
+    case "claude": {
+      const root = join10(p2, ".claude", "skills", SKILL_DIR_NAME);
+      return {
+        agent,
+        scope: "project",
+        root,
+        adapters: [{ source: "claude-code/SKILL.md", dest: join10(root, "SKILL.md") }],
+        marked: [],
+        optional: [],
+        summary: "Claude Code project-level skill"
+      };
+    }
+    case "codex":
+      return {
+        agent,
+        scope: "project",
+        root: user.root,
+        adapters: [],
+        marked: [{ source: "codex/AGENTS.block.md", dest: join10(p2, "AGENTS.md") }],
+        optional: [],
+        summary: "Codex block in the project's AGENTS.md"
+      };
+    case "cursor":
+      return {
+        agent,
+        scope: "project",
+        root: user.root,
+        adapters: [
+          {
+            source: "cursor/local-executor.mdc",
+            dest: join10(p2, ".cursor", "rules", "local-executor.mdc")
+          }
+        ],
+        marked: [],
+        optional: [],
+        summary: "Cursor project rule"
+      };
+    case "windsurf":
+      return {
+        agent,
+        scope: "project",
+        root: user.root,
+        adapters: [
+          {
+            source: "windsurf/local-executor.md",
+            dest: join10(p2, ".windsurf", "rules", "local-executor.md")
+          }
+        ],
+        marked: [],
+        optional: [],
+        summary: "Windsurf project rule"
+      };
+  }
+}
+function resolveTargets(agents, ctx, opts) {
+  const out = [];
+  for (const a of agents) {
+    out.push(userTarget(a, ctx));
+    if (opts.project) {
+      const pt = projectTarget(a, ctx);
+      if (pt) out.push(pt);
+    }
+  }
+  return out;
+}
+function configPathFor(root) {
+  return join10(root, "runtime", "config.json");
+}
+
+// src/agents/install.ts
+function templateVars(root, model, version) {
+  const r = toPosix(root);
+  return {
+    LEX_ROOT: r,
+    LEX_CORE: `${r}/core`,
+    LEX_RUNTIME: `${r}/runtime`,
+    LEX_CONFIG: `${r}/runtime/config.json`,
+    LEX_MODEL: model,
+    LEX_VERSION: version
+  };
+}
+function renderTemplate(text3, vars) {
+  return text3.replace(
+    /\{\{(LEX_[A-Z_]+)\}\}/g,
+    (whole, key) => key in vars ? vars[key] : whole
+  );
+}
+var defaultRuntimeConfig = {
+  ollama_url: "http://localhost:11434",
+  model: "qwen3.5:9b",
+  fallback_model: "qwen3.5:4b",
+  num_ctx: 16384,
+  temperature: 0.1,
+  keep_alive: "30m",
+  timeout_seconds: 600,
+  think: false
+};
+async function copyCore(src, dest, vars) {
+  await ensureDir(dest);
+  for (const name of await readdir2(src)) {
+    const text3 = await readFile2(join11(src, name), "utf8");
+    await writeText(join11(dest, name), name.endsWith(".md") ? renderTemplate(text3, vars) : text3);
+  }
+}
+async function installTarget(input) {
+  const { target, skillSource, model, version } = input;
+  const actions = [];
+  const vars = templateVars(target.root, model, version);
+  const ownsRoot = target.scope === "user" || target.agent === "claude";
+  const owned = [];
+  const marked = [];
+  if (ownsRoot) {
+    const existed = await exists(target.root);
+    await ensureDir(target.root);
+    await copyCore(join11(skillSource, "core"), join11(target.root, "core"), vars);
+    await writeText(join11(target.root, "core", "models.md"), input.modelsDoc);
+    const runtimeDest = join11(target.root, "runtime");
+    const configPath = configPathFor(target.root);
+    const existing = await readJsonOr(configPath, {});
+    await ensureDir(runtimeDest);
+    await copyDir(join11(skillSource, "runtime"), runtimeDest);
+    const shipped = await readJsonOr(
+      join11(skillSource, "runtime", "config.json"),
+      {}
+    );
+    const merged = {
+      ...defaultRuntimeConfig,
+      ...shipped,
+      ...existing,
+      model,
+      ollama_url: input.ollamaUrl
+    };
+    await writeJson(configPath, merged);
+    owned.push(target.root);
+    actions.push(`${existed ? "Updated" : "Created"} ${target.root}`);
+  }
+  for (const a of target.adapters) {
+    const text3 = await readFile2(join11(skillSource, "adapters", a.source), "utf8");
+    await writeText(a.dest, renderTemplate(text3, vars));
+    if (!ownsRoot || !a.dest.startsWith(target.root)) owned.push(a.dest);
+    actions.push(`Wrote ${a.dest}`);
+  }
+  for (const o of target.optional) {
+    if (!await isDirectory(o.ifDirExists)) continue;
+    const text3 = await readFile2(join11(skillSource, "adapters", o.adapter.source), "utf8");
+    await writeText(o.adapter.dest, renderTemplate(text3, vars));
+    owned.push(
+      dirname2(o.adapter.dest) === o.ifDirExists ? o.adapter.dest : dirname2(o.adapter.dest)
+    );
+    actions.push(`Wrote ${o.adapter.dest}`);
+  }
+  for (const m of target.marked) {
+    const body = renderTemplate(
+      await readFile2(join11(skillSource, "adapters", m.source), "utf8"),
+      vars
+    );
+    const current = await readTextOr(m.dest, "");
+    const next = upsertBlock(current, body);
+    if (next !== current) await writeText(m.dest, next);
+    marked.push(m.dest);
+    actions.push(
+      `${current.includes("<!-- lex:start -->") ? "Refreshed" : "Appended"} lex block in ${m.dest}`
+    );
+  }
+  const record = {
+    agent: target.agent,
+    scope: target.scope,
+    root: target.root,
+    configPath: configPathFor(target.root),
+    owned,
+    marked,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version
+  };
+  return { record, actions };
+}
+async function uninstallRecord(rec) {
+  const actions = [];
+  for (const p2 of rec.owned) {
+    if (await exists(p2)) {
+      await removePath(p2);
+      actions.push(`Removed ${p2}`);
+    }
+  }
+  for (const f of rec.marked) {
+    const current = await readTextOr(f, "");
+    if (!current) continue;
+    const next = removeBlock(current);
+    if (next === current) continue;
+    if (next.trim().length === 0 && basename(f) === "AGENTS.md") {
+      await writeText(f, "");
+    } else {
+      await writeText(f, next);
+    }
+    actions.push(`Removed lex block from ${f}`);
+  }
+  return actions;
+}
+async function updateConfigModel(configPath, model) {
+  if (!await exists(configPath)) return false;
+  const cfg = await readJsonOr(configPath, {});
+  await writeJson(configPath, { ...defaultRuntimeConfig, ...cfg, model });
+  return true;
+}
+
+// src/models/doc.ts
+function gb2(n) {
+  return `${Math.round(n * 10) / 10} GB`;
+}
+function renderModelsDoc(hw, report, chosen) {
+  const top = report.list[0];
+  const tierRows = tiers.map((t) => {
+    const mark = t === report.tier ? " \u2190 this machine" : "";
+    const alts = t.alsoOffer.map((a) => `\`${a}\``).join(", ");
+    return `| ${t.label}${mark} | \`${t.recommended}\` | ${alts} | ${t.reason} |`;
+  }).join("\n");
+  const catalogRows = catalog.map(
+    (m) => `| \`${m.tag}\` | ${m.params} | ~${m.sizeGB} GB | ${m.contextK}K | ${m.notes}${m.appleOnly ? " (Apple Silicon only)" : ""} |`
+  ).join("\n");
+  const adjustments = report.adjustments.length > 0 ? `
+**Adjustments applied on this machine:**
+${report.adjustments.map((a) => `- ${a}`).join("\n")}
+` : "";
+  const gpu = hw.gpu.kind === "apple" ? "Apple Silicon (unified memory)" : hw.gpu.kind === "none" ? "none detected" : `${hw.gpu.model}${hw.gpu.vramGB ? ` (${gb2(hw.gpu.vramGB)} VRAM)` : ""}`;
+  return `# Choosing the executor model
+
+Generated by \`local-executor\` for this machine on ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}. Catalog last verified against ollama.com on ${lastVerified}.
+
+## This machine
+
+| | |
+|---|---|
+| OS / arch | ${hw.platform} / ${hw.arch} |
+| CPU | ${hw.cpuModel} (${hw.physicalCores} physical / ${hw.logicalCores} logical cores) |
+| RAM | ${gb2(hw.totalRamGB)} total, ${gb2(hw.freeRamGB)} free at install time |
+| GPU | ${gpu} |
+| Effective memory for models | **${gb2(report.effectiveMemory.gb)}** (${report.effectiveMemory.rule}) |
+| Free disk near the model store | ${gb2(hw.freeDiskGB)} (${hw.modelsDir}) |
+| Configured executor | **\`${chosen}\`** |
+| Top recommendation | \`${top?.tag ?? "n/a"}\` \u2014 ${top?.reason ?? ""} |
+${adjustments}
+## The rule
+
+The model file plus its context cache must fit in memory alongside the OS, the agent, and an editor. On Apple Silicon roughly 70% of unified RAM is usable for the model; on a PC with a discrete NVIDIA/AMD GPU, count VRAM; on CPU-only x64, count about half of RAM. A model that doesn't fit swaps to disk and drops to 1\u20132 tokens/sec \u2014 worse than useless.
+
+Mixture-of-Experts models (e.g. Gemma 4 26B, "4B active") are fast to compute but still need the **whole** model in memory. Active-parameter count is not memory footprint. That is why a 26B MoE does not fit on a 16 GB Mac even though only 4B parameters run per token.
+
+## Tiers
+
+| Effective memory | Recommended | Alternatives | Notes |
+|---|---|---|---|
+${tierRows}
+
+Below 4 physical cores on a CPU-only machine, step down until the recommended model gets smaller. If the recommended model needs more than the free disk \xD7 1.5, step down and free space.
+
+## Catalog (sizes approximate)
+
+| Tag | Parameters | Download | Context | Notes |
+|---|---|---|---|---|
+${catalogRows}
+
+Verify tag names on ollama.com before pulling something not in this list \u2014 tags change between releases.
+
+## Cold start
+
+The first call after the model unloads takes 10\u201330 s while it loads. The runtime passes \`keep_alive\` (default 30m, in \`config.json\`) so the model stays resident between packets. Set \`OLLAMA_KEEP_ALIVE=-1\` in the environment to keep it loaded permanently while working.
+
+## Context window
+
+\`num_ctx\` in \`config.json\` is 16384. Larger contexts cost memory (the KV cache grows linearly). If the model starts swapping, drop \`num_ctx\` to 8192 before stepping down a model size \u2014 most packets fit in 8k.
+
+## Changing the model
+
+Run \`lex switch <tag>\`. It pulls the tag if needed and updates every installed \`config.json\`. Editing \`config.json\` by hand and running \`ollama pull <tag>\` also works.
+`;
+}
+
+// src/steps/skills.ts
+init_fs();
+
+// src/util/pkg.ts
+import { readFileSync } from "fs";
+import { dirname as dirname3, join as join12 } from "path";
+import { fileURLToPath } from "url";
+var cached = null;
+function packageRoot() {
+  return locate().root;
+}
+function packageVersion() {
+  return locate().pkg.version;
+}
+function skillSourceDir() {
+  return join12(packageRoot(), "skill");
+}
+function locate() {
+  if (cached) return cached;
+  let dir = dirname3(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    try {
+      const pkg = JSON.parse(readFileSync(join12(dir, "package.json"), "utf8"));
+      if (pkg.name === "local-executor") {
+        cached = { root: dir, pkg };
+        return cached;
+      }
+    } catch {
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("local-executor: cannot locate package root (package.json not found)");
+}
+
+// src/steps/skills.ts
+init_state();
+async function stepSkills(ctx) {
+  header(
+    "5/6",
+    "Skill install",
+    "One canonical pipeline body plus a thin adapter per agent, with paths rewritten for each location."
+  );
+  if (ctx.agents.length === 0) {
+    info("Nothing to install.");
+    return;
+  }
+  if (!ctx.hw || !ctx.report || !ctx.model)
+    throw new Error("internal: hardware and model steps must run first");
+  const targets = resolveTargets(
+    ctx.agents,
+    { home: home(), projectRoot: ctx.projectRoot },
+    { project: ctx.installProject }
+  );
+  const modelsDoc = renderModelsDoc(ctx.hw, ctx.report, ctx.model);
+  const version = packageVersion();
+  let manifest = await readManifest();
+  for (const target of targets) {
+    const outcome = await installTarget({
+      target,
+      skillSource: skillSourceDir(),
+      model: ctx.model,
+      ollamaUrl: ctx.client.baseUrl,
+      version,
+      modelsDoc
+    });
+    ctx.installs.push(outcome);
+    manifest = upsertInstall(manifest, outcome.record);
+    success(`${target.summary}`);
+    for (const a of outcome.actions) message(pc.dim(`  ${a.replace(home(), "~")}`));
+  }
+  manifest.model = ctx.model;
+  await writeManifest(manifest);
+  info(`Install manifest: ${contractTilde((await Promise.resolve().then(() => (init_state(), state_exports))).manifestPath())}`);
+}
+
+// src/steps/verify.ts
+import { mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join13 } from "path";
+init_fs();
+var VERIFY_TEST = `import { test } from "node:test";
+import assert from "node:assert/strict";
+import { fortyTwo } from "./answer.mjs";
+
+test("fortyTwo returns 42", () => {
+  assert.equal(fortyTwo(), 42);
+});
+`;
+var VERIFY_PACKET = `# Task: Return 42
+
+## Goal (required)
+Create \`answer.mjs\` exporting a function \`fortyTwo\` that returns the number 42.
+
+## Files you may change (required)
+- answer.mjs \u2014 create this file
+
+You may NOT change any other file.
+
+## Conventions (required)
+- Language/version: JavaScript, Node.js 20, ESM
+- Style: named export, no console output, no comments needed
+- Allowed dependencies: none
+- Modern practices:
+  - ESM \`export\`, never CommonJS
+  - \`const\` and arrow functions or plain \`function\`; no \`var\`
+
+## Existing code
+answer.mjs does not exist yet.
+
+## Tests that must pass (required)
+Command: \`node --test answer.test.mjs\`
+
+### answer.test.mjs
+\`\`\`js
+${VERIFY_TEST}\`\`\`
+
+## Do NOT
+- Do not modify answer.test.mjs
+- Do not create any file other than answer.mjs
+`;
+async function checkLocal(root) {
+  const script = join13(root, "runtime", "check_local.mjs");
+  if (!await exists(script)) return { check: "ERROR", checkMessage: `missing ${script}` };
+  try {
+    const r = await run(process.execPath, [script, "--json"], { timeoutMs: 15e3 });
+    const parsed = JSON.parse(r.stdout.trim().split("\n").at(-1) ?? "{}");
+    const status = parsed.status;
+    return { check: status ?? "ERROR", checkMessage: parsed.message ?? r.stderr };
+  } catch (err) {
+    return { check: "ERROR", checkMessage: err.message };
+  }
+}
+async function runVerifyPacket(root) {
+  const work = await mkdtemp(join13(tmpdir(), "lex-verify-"));
+  try {
+    await writeFile2(join13(work, "answer.test.mjs"), VERIFY_TEST);
+    await writeFile2(join13(work, "packet.md"), VERIFY_PACKET);
+    const exec = await run(
+      process.execPath,
+      [
+        join13(root, "runtime", "run_executor.mjs"),
+        "--packet",
+        join13(work, "packet.md"),
+        "--out",
+        join13(work, "response.md"),
+        "--apply",
+        "--root",
+        work,
+        "--json"
+      ],
+      { timeoutMs: 6e5 }
+    );
+    let tps = null;
+    try {
+      const j = JSON.parse(exec.stdout.trim().split("\n").at(-1) ?? "{}");
+      tps = j.tokensPerSec ?? null;
+    } catch {
+    }
+    if (!exec.ok) {
+      const raw = (await readTextOr(join13(work, "response.md"), "")).slice(0, 400);
+      return {
+        packet: "fail",
+        packetDetail: `run_executor exited ${exec.exitCode ?? "?"}: ${exec.stderr.trim().split("\n")[0] ?? ""}${raw ? `
+Executor said: ${raw}` : ""}`,
+        tokensPerSec: tps
+      };
+    }
+    const test = await run(process.execPath, ["--test", "answer.test.mjs"], {
+      cwd: work,
+      timeoutMs: 6e4
+    });
+    if (test.ok)
+      return {
+        packet: "pass",
+        packetDetail: "executor wrote answer.mjs and node --test passed",
+        tokensPerSec: tps
+      };
+    const answer = await readTextOr(join13(work, "answer.mjs"), "(answer.mjs not written)");
+    return {
+      packet: "fail",
+      packetDetail: `tests failed. answer.mjs was:
+${answer.slice(0, 400)}`,
+      tokensPerSec: tps
+    };
+  } finally {
+    await rm2(work, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function stepVerify(ctx) {
+  header(
+    "6/6",
+    "Verify",
+    "Run the installed check script and push one tiny real packet through the executor."
+  );
+  const roots = [
+    ...new Set(
+      ctx.installs.filter((i) => i.record.owned.includes(i.record.root)).map((i) => i.record.root)
+    )
+  ];
+  if (roots.length === 0) {
+    info("No installs to verify.");
+    return;
+  }
+  if (ctx.opts.skipVerify) {
+    warn("--skip-verify: not running the end-to-end check.");
+    return;
+  }
+  let packetDone = null;
+  for (const root of roots) {
+    const sp = spinner2();
+    sp.start(`Checking ${root}\u2026`);
+    const check = await checkLocal(root);
+    let packet = {
+      packet: "skipped",
+      packetDetail: check.checkMessage,
+      tokensPerSec: null
+    };
+    if (check.check === "READY") {
+      if (packetDone) {
+        packet = { ...packetDone, packetDetail: "same executor as above" };
+      } else {
+        sp.message(`Sending the "return 42" packet through ${root}\u2026`);
+        packet = await runVerifyPacket(root);
+        packetDone = packet;
+      }
+    }
+    const result = { root, ...check, ...packet };
+    ctx.verify.push(result);
+    const label = `${check.check}${packet.packet !== "skipped" ? ` \xB7 packet ${packet.packet}` : ""}`;
+    if (check.check === "READY" && packet.packet === "pass")
+      sp.stop(`${root}: ${pc.green(label)}`);
+    else if (check.check === "READY")
+      sp.error(`${root}: ${pc.red(label)} \u2014 ${packet.packetDetail.split("\n")[0]}`);
+    else sp.error(`${root}: ${pc.yellow(label)} \u2014 ${check.checkMessage}`);
+  }
+}
+
+// src/commands/init.ts
+init_fs();
+var startHints = {
+  claude: 'In Claude Code, say: "use the local executor to implement X"',
+  codex: 'In Codex CLI, say: "use the local executor pipeline to implement X"',
+  cursor: 'In Cursor chat, say: "use the local executor pipeline to implement X" (rule: .cursor/rules/local-executor.mdc)',
+  windsurf: 'In Windsurf Cascade, say: "use the local executor pipeline to implement X" (rule: .windsurf/rules/local-executor.md)'
+};
+function summaryLines(ctx) {
+  const lines = [];
+  lines.push(
+    `Ollama    ${ctx.ollama.version ? `v${ctx.ollama.version}` : "not reachable"}${ctx.ollama.skipped ? " (setup skipped)" : ""} at ${ctx.client.baseUrl}`
+  );
+  const speed = ctx.warmup?.tokensPerSec ? `${ctx.warmup.tokensPerSec} tok/s` : ctx.pulled ? "speed not measured" : "not pulled";
+  lines.push(`Model     ${ctx.model ?? "none"} \u2014 ${speed}`);
+  if (ctx.installs.length === 0) lines.push("Agents    none configured");
+  for (const i of ctx.installs) {
+    const adapter = i.record.marked[0] ?? i.record.owned.find((p2) => p2 !== i.record.root) ?? i.record.root;
+    lines.push(
+      `${agentNames[i.record.agent].padEnd(9)} ${i.record.scope} \u2192 ${contractTilde(adapter)}`
+    );
+  }
+  const v = ctx.verify;
+  if (v.length > 0) {
+    const pass = v.filter((r) => r.packet === "pass").length;
+    const skipped = v.filter((r) => r.packet === "skipped").length;
+    const ran = v.length - skipped;
+    const why = skipped > 0 ? ` (${skipped} skipped: ${v.find((r) => r.packet === "skipped")?.check.toLowerCase()})` : "";
+    lines.push(
+      `Verify    ${ran === 0 ? "not run" : `${pass}/${ran} install(s) passed the end-to-end packet`}${why}`
+    );
+  }
+  return lines;
+}
+async function runInit(opts) {
+  configureUi({ yes: opts.yes, json: opts.json });
+  if (!ui.tty && !opts.yes && !opts.json) {
+    process.stderr.write("lex: stdout is not a terminal; running as if --yes was given.\n");
+  }
+  const ctx = {
+    opts,
+    client: new OllamaClient(opts.ollamaUrl),
+    cwd: process.cwd(),
+    ollama: { binary: null, version: null, latest: null, skipped: false },
+    detections: [],
+    agents: [],
+    projectRoot: null,
+    installProject: false,
+    installs: [],
+    verify: [],
+    warnings: []
+  };
+  intro2(`local-executor v${packageVersion()}`);
+  message(
+    "Planner (your cloud agent) \u2192 Executor (local model via Ollama) \u2192 Auditor (strong model, fresh context)."
+  );
+  await stepOllama(ctx);
+  await stepHardware(ctx);
+  await stepModel(ctx);
+  await stepAgents(ctx);
+  await stepSkills(ctx);
+  await stepVerify(ctx);
+  const failedVerify = ctx.verify.some((r) => r.packet === "fail");
+  if (opts.json) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: !failedVerify,
+          ollama: ctx.ollama,
+          hardware: ctx.hw,
+          effectiveMemoryGB: ctx.report?.effectiveMemory.gb,
+          tier: ctx.report?.tier.label,
+          model: ctx.model,
+          pulled: ctx.pulled ?? false,
+          tokensPerSec: ctx.warmup?.tokensPerSec ?? null,
+          agents: ctx.agents,
+          installs: ctx.installs.map((i) => i.record),
+          verify: ctx.verify,
+          warnings: ctx.warnings
+        },
+        null,
+        2
+      )}
+`
+    );
+  } else {
+    box2(summaryLines(ctx).join("\n"), "Summary");
+    for (const w of ctx.warnings) warn(w);
+    const hints = ctx.agents.map((a) => `\u2022 ${startHints[a]}`);
+    if (hints.length > 0) note2(hints.join("\n"), "How to start");
+    outro2(
+      failedVerify ? pc.red("Setup finished with a failing verification. See above.") : "Done."
+    );
+  }
+  return failedVerify ? 3 : 0;
+}
+
+// src/commands/models.ts
+async function runModels(opts) {
+  configureUi({ json: opts.json });
+  const hw = await detectHardware();
+  const report = buildRecommendation(hw, { includeAll: opts.all });
+  if (opts.json) {
+    process.stdout.write(
+      `${JSON.stringify({ hardware: hw, effectiveMemory: report.effectiveMemory, tier: report.tier.label, adjustments: report.adjustments, models: report.list.map(({ model: _m, ...r }) => r), lastVerified }, null, 2)}
+`
+    );
+    return 0;
+  }
+  intro2("lex models");
+  table(hardwareRows(hw));
+  info(
+    `Effective memory: ${pc.bold(`${report.effectiveMemory.gb} GB`)} (${report.effectiveMemory.rule}) \u2192 tier ${report.tier.label}`
+  );
+  for (const a of report.adjustments) warn(a);
+  const rows = report.list.map((r) => {
+    const flags = [
+      !r.fitsDisk ? pc.yellow("needs disk") : "",
+      !r.fitsMemory ? pc.yellow("may swap") : ""
+    ].filter(Boolean).join(" ");
+    return [
+      `${r.recommended ? "\u2605 " : "  "}${r.tag}`,
+      `~${String(r.sizeGB).padStart(4)} GB  ${r.reason}${flags ? `  [${flags}]` : ""}`
+    ];
+  });
+  table(rows);
+  outro2(
+    `Catalog last verified against ollama.com on ${lastVerified}. Nothing was installed.${opts.all ? "" : " Use --all to include models that do not fit."}`
+  );
+  return 0;
+}
+
+// src/commands/switch.ts
+init_fs();
+init_state();
+async function runSwitch(tag, opts) {
+  configureUi({ yes: opts.yes, json: opts.json });
+  if (!isValidTag(tag)) {
+    error(`"${tag}" does not look like an Ollama tag.`);
+    return 1;
+  }
+  const manifest = await readManifest();
+  if (manifest.installs.length === 0) {
+    error("No installs recorded. Run `lex init` first.");
+    return 1;
+  }
+  intro2(`lex switch ${tag}`);
+  const client = new OllamaClient(opts.ollamaUrl);
+  const ctx = {
+    client,
+    opts: { ...opts, skipPull: false },
+    warnings: []
+  };
+  let pulled = false;
+  if (await client.isUp()) {
+    if (await client.hasModel(tag).catch(() => false)) {
+      success(`${tag} is already pulled.`);
+      pulled = true;
+    } else {
+      const known = findModel(tag);
+      info(
+        `Download: ${known ? `about ${known.sizeGB} GB` : "size unknown (not in the catalog)"}.`
+      );
+      if (await confirm2(`Pull ${tag} now?`, true)) pulled = await pullModel(ctx, tag);
+      if (!pulled) {
+        error(`Could not pull ${tag}; configs were not changed.`);
+        return 2;
+      }
+    }
+    await warmupModel(ctx, tag);
+  } else {
+    warn(
+      `Ollama is not reachable at ${opts.ollamaUrl}; updating configs without pulling. Run: ollama pull ${tag}`
+    );
+  }
+  const updated = [];
+  const missing = [];
+  for (const rec of manifest.installs) {
+    if (!rec.owned.includes(rec.root)) continue;
+    if (await updateConfigModel(rec.configPath, tag)) updated.push(rec.configPath);
+    else missing.push(rec.configPath);
+  }
+  manifest.model = tag;
+  await writeManifest(manifest);
+  for (const u of updated) success(`Updated ${contractTilde(u)}`);
+  for (const m of missing) warn(`Missing ${contractTilde(m)} (re-run lex init)`);
+  if (opts.json)
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, model: tag, pulled, tokensPerSec: ctx.warmup?.tokensPerSec ?? null, updated, missing })}
+`
+    );
+  else outro2(`Executor model is now ${tag} in ${updated.length} config file(s).`);
+  return 0;
+}
+
+// src/commands/uninstall.ts
+init_fs();
+init_state();
+async function runUninstall(opts) {
+  configureUi({ yes: opts.yes, json: opts.json });
+  const manifest = await readManifest();
+  const targets = manifest.installs.filter((r) => !opts.agents || opts.agents.includes(r.agent));
+  intro2("lex uninstall");
+  if (targets.length === 0) {
+    info("Nothing recorded to uninstall.");
+    if (opts.json) process.stdout.write(`${JSON.stringify({ ok: true, removed: [] })}
+`);
+    return 0;
+  }
+  const preview = targets.map((r) => {
+    const items = [
+      ...r.owned.map((p2) => `delete  ${contractTilde(p2)}`),
+      ...r.marked.map((p2) => `unmark  ${contractTilde(p2)} (block only)`)
+    ];
+    return `${agentNames[r.agent]} (${r.scope})
+  ${items.join("\n  ")}`;
+  }).join("\n");
+  note2(preview, "This will");
+  if (!await confirm2("Proceed?", true)) return 130;
+  const removed = [];
+  for (const rec of targets) {
+    const actions = await uninstallRecord(rec);
+    removed.push(...actions);
+    for (const a of actions) success(a.replace(process.env.HOME ?? "", "~"));
+  }
+  manifest.installs = manifest.installs.filter((r) => !targets.includes(r));
+  await writeManifest(manifest);
+  if (opts.json) process.stdout.write(`${JSON.stringify({ ok: true, removed })}
+`);
+  else outro2(`Removed ${targets.length} install(s). Ollama and pulled models were left alone.`);
+  return 0;
+}
+
+// src/util/url.ts
+function normalizeUrl(raw) {
+  let s = raw.trim();
+  if (!/^https?:\/\//.test(s)) s = `http://${s}`;
+  s = s.replace(/\/+$/, "");
+  s = s.replace("://0.0.0.0", "://localhost");
+  return s;
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("lex").description(
+  "Set up a planner \u2192 local executor \u2192 auditor coding pipeline.\nInstalls Ollama, picks a model for your hardware, and teaches your AI agents to use it."
+).version(packageVersion(), "-v, --version").showHelpAfterError().addHelpText(
+  "after",
+  `
+Examples:
+  $ npx local-executor                 interactive setup (same as: lex init)
+  $ lex --yes                          zero prompts, sane defaults
+  $ lex init --model qwen3.5:4b --agents claude,codex --yes
+  $ lex init --skip-ollama --agents cursor --project
+  $ lex models                         ranked catalog for this machine
+  $ lex doctor                         diagnostics, non-zero exit on failure
+  $ lex switch gemma4:e4b              pull + update every installed config
+  $ lex uninstall --agents codex       remove what lex installed for Codex
+`
+);
+var ollamaUrlOption = new Option("--ollama-url <url>", "Ollama server URL").default(DEFAULT_OLLAMA_URL).env("OLLAMA_HOST");
+function initCommand(cmd) {
+  return cmd.option("-y, --yes", "accept defaults; never prompt", false).option("--json", "machine-readable output; implies --yes", false).option("-m, --model <tag>", "executor model tag (skips the selection prompt)").option(
+    "-a, --agents <list>",
+    "comma-separated: claude,codex,cursor,windsurf",
+    (v) => parseAgentList(v)
+  ).option("--skip-ollama", "do not detect/install/start Ollama", false).option("--skip-pull", "do not pull the model", false).option("--skip-verify", "do not run the end-to-end check", false).option("--project", "also install project-level files (requires a git repo)").option("--no-project", "never install project-level files").option(
+    "--allow-install",
+    "in --yes mode, permit running the Ollama install/upgrade command",
+    false
+  ).addOption(ollamaUrlOption).action(async (opts) => {
+    const code2 = await runInit({
+      yes: Boolean(opts.yes) || Boolean(opts.json),
+      json: Boolean(opts.json),
+      ollamaUrl: normalizeUrl(opts.ollamaUrl),
+      model: opts.model,
+      agents: opts.agents,
+      skipOllama: Boolean(opts.skipOllama),
+      skipPull: Boolean(opts.skipPull),
+      skipVerify: Boolean(opts.skipVerify),
+      project: typeof opts.project === "boolean" ? opts.project : void 0,
+      allowInstall: Boolean(opts.allowInstall)
+    });
+    process.exitCode = code2;
+  });
+}
+initCommand(
+  program.command("init", { isDefault: true }).description("interactive setup (default command)")
+);
+program.command("doctor").description("re-run all checks and print a diagnostic table; exits 1 on any failure").option("--json", "machine-readable output", false).addOption(ollamaUrlOption).action(async (opts) => {
+  process.exitCode = await runDoctor({
+    json: Boolean(opts.json),
+    ollamaUrl: normalizeUrl(opts.ollamaUrl)
+  });
+});
+program.command("models").description("show the model catalog ranked for this machine (installs nothing)").option("--json", "machine-readable output", false).option("--all", "include models that do not fit in memory", false).action(async (opts) => {
+  process.exitCode = await runModels({ json: Boolean(opts.json), all: Boolean(opts.all) });
+});
+program.command("switch <tag>").description("pull <tag> if needed and point every installed config.json at it").option("-y, --yes", "never prompt", false).option("--json", "machine-readable output; implies --yes", false).addOption(ollamaUrlOption).action(async (tag, opts) => {
+  process.exitCode = await runSwitch(tag, {
+    yes: Boolean(opts.yes) || Boolean(opts.json),
+    json: Boolean(opts.json),
+    ollamaUrl: normalizeUrl(opts.ollamaUrl)
+  });
+});
+program.command("uninstall").description("remove what lex installed (respects marker blocks in shared files)").option("-y, --yes", "never prompt", false).option("--json", "machine-readable output; implies --yes", false).option("-a, --agents <list>", "only these agents", (v) => parseAgentList(v)).action(async (opts) => {
+  process.exitCode = await runUninstall({
+    yes: Boolean(opts.yes) || Boolean(opts.json),
+    json: Boolean(opts.json),
+    agents: opts.agents
+  });
+});
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`lex: ${err.message}
+`);
+  process.exitCode = 1;
+});