@tiens.nguyen/gonext-cli 1.0.350

package/gonext-cli.mjs

@@ -0,0 +1,3216 @@
+#!/usr/bin/env node
+/**
+ * GoNext local worker:
+ * - `gonext-cli set <workerKey> [--api-base URL]`
+ *   writes ~/.gonext/worker.env
+ * - `gonext-cli ws-ping-test` — POST worker ws-ping (needs GONEXT_* env)
+ * - `gonext-cli simulate-chat [text]` — claim next chat job, push fake reply like the real worker (needs GONEXT_* env)
+ * - `gonext-cli embed --model <mlx-embed-model> [--port 8085]` — run the MLX embeddings server (RAG); use a separate terminal
+ * - `gonext-cli workspace add|remove|list …` — manage local code folders the agent may read/edit/test in
+ * - `gonext-cli` — starts polling loop (claims jobs and runs models)
+ */
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { execFile as execFileCallback, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { homedir, platform, tmpdir } from "node:os";
+import { dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { createRequire } from "node:module";
+import dotenv from "dotenv";
+import OpenAI from "openai";
+
+const WORKER_DIR = dirname(fileURLToPath(import.meta.url));
+
+// Running worker version, read from the package's own package.json (single source of
+// truth) so the startup banner shows exactly which build a box is running (task #105).
+const WORKER_VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("./package.json").version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
+
+/** Avoid `node:child_process/promises` — not available on some Node builds / older runtimes. */
+const execFile = promisify(execFileCallback);
+
+const ENV_FILE = join(homedir(), ".gonext", "worker.env");
+const preloadedWorkerKey = String(process.env.GONEXT_WORKER_KEY ?? "").trim();
+const envFileLoad = dotenv.config({ path: ENV_FILE });
+dotenv.config();
+
+const args = process.argv.slice(2);
+
+function workerKeyFingerprint(secret) {
+  const v = String(secret ?? "").trim();
+  if (!v) return "";
+  return createHash("sha256").update(v, "utf8").digest("hex").slice(0, 12);
+}
+
+function maskWorkerKey(secret) {
+  const v = String(secret ?? "").trim();
+  if (!v) return "(empty)";
+  if (v.length <= 12) return `${v.slice(0, 3)}***`;
+  return `${v.slice(0, 8)}...${v.slice(-4)}`;
+}
+
+function printHelp() {
+  console.log(`
+gonext-cli
+
+Usage:
+  gonext-cli
+  gonext-cli login [--api-base <url>]   # browser sign-in → writes ~/.gonext/worker.env
+  gonext-cli set <workerKey> [--api-base <url>]
+  gonext-cli start | stop | status | restart   # run the polling daemon in the background
+  gonext-cli logs [--lines N]                  # tail the background daemon log
+  gonext-cli doctor                            # download + start the base chat model if needed
+  gonext-cli ws-ping-test   # POST /api/worker/ws-ping-test (needs GONEXT_* env)
+  gonext-cli simulate-chat [text...]   # claim next chat job, fake reply (stop normal worker first)
+
+Examples:
+  gonext-cli set abc123 --api-base https://hwohu56e8d.execute-api.ap-southeast-1.amazonaws.com
+  gonext-cli
+  gonext-cli ws-ping-test
+  gonext-cli simulate-chat "Hello from a fake model"
+
+Env (optional):
+  GONEXT_SIMULATE_TEXT   default body for simulate-chat when no args
+  GONEXT_MLX_LM_PYTHON   Python executable for MLX LM native probe (default: python3)
+  GONEXT_OCR_MODEL_PATH  Local GLM-OCR-bf16 directory (default: ~/mlx-models/GLM-OCR-bf16)
+  GONEXT_OCR_DEBUG=1     Print raw OCR stdout/stderr snippets for troubleshooting
+`);
+}
+
+function parseFlag(name) {
+  const idx = args.indexOf(name);
+  if (idx >= 0 && args[idx + 1]) {
+    return args[idx + 1];
+  }
+  return undefined;
+}
+
+async function setConfig() {
+  const workerKey = args[1]?.trim();
+  if (!workerKey) {
+    console.error("Missing worker key. Usage: gonext-cli set <workerKey>");
+    process.exit(1);
+  }
+  const currentRaw = await readFile(ENV_FILE, "utf8").catch(() => "");
+  const current = dotenv.parse(currentRaw);
+  const apiBaseFromFlag = parseFlag("--api-base");
+  const next = {
+    GONEXT_API_BASE: (
+      apiBaseFromFlag ??
+      current.GONEXT_API_BASE ??
+      process.env.GONEXT_API_BASE ??
+      ""
+    ).replace(/\/+$/, ""),
+    GONEXT_WORKER_KEY: workerKey,
+    GONEXT_POLL_MS: "500",
+  };
+  await mkdir(join(homedir(), ".gonext"), { recursive: true });
+  await writeFile(
+    ENV_FILE,
+    `GONEXT_API_BASE=${next.GONEXT_API_BASE}\nGONEXT_WORKER_KEY=${next.GONEXT_WORKER_KEY}\nGONEXT_POLL_MS=${next.GONEXT_POLL_MS}\n`,
+    "utf8"
+  );
+  console.log(`Saved ${ENV_FILE}`);
+  if (!next.GONEXT_API_BASE) {
+    console.log("Tip: set API base too: gonext-cli set <workerKey> --api-base <https-url>");
+  }
+  return;
+}
+
+if (args.includes("--help") || args.includes("-h")) {
+  printHelp();
+  process.exit(0);
+}
+if (args[0] === "set") {
+  await setConfig();
+  process.exit(0);
+}
+if (args[0] === "login") {
+  // Task #127, Phase 1: browser device-pairing → writes worker.env. `--api-base` overrides
+  // which API to pair against (defaults to the production API).
+  const { deviceLogin, DEFAULT_API_BASE } = await import("./device-login.mjs");
+  const apiBaseFlag = parseFlag("--api-base");
+  try {
+    await deviceLogin({
+      apiBase:
+        apiBaseFlag ||
+        (process.env.GONEXT_API_BASE ?? "").trim() ||
+        DEFAULT_API_BASE,
+    });
+    process.exit(0);
+  } catch (e) {
+    console.error(`[gonext-worker] login failed: ${e instanceof Error ? e.message : e}`);
+    if (e && e.code === "PAIRING_UNSUPPORTED") {
+      console.error(
+        "Set it manually instead: gonext-cli set <workerKey> --api-base <url>"
+      );
+    }
+    process.exit(1);
+  }
+}
+// Task #127, Phase 2: daemon lifecycle from a plain terminal (no GoTerminal). start runs
+// the polling worker DETACHED; stop/status/logs manage it. All no-op-safe (BC4: never
+// double-spawn a second poller).
+if (["start", "stop", "status", "logs", "restart"].includes(args[0])) {
+  const ctl = await import("./daemon-control.mjs");
+  if (args[0] === "status") {
+    const s = await ctl.daemonStatus();
+    if (s.running) {
+      const who = s.pidFilePid ? `pid ${s.pidFilePid}` : `pid ${s.pids.join(", ")}`;
+      console.log(`[gonext-worker] daemon RUNNING (${who}). Logs: ${ctl.LOG_FILE}`);
+    } else {
+      console.log("[gonext-worker] daemon is NOT running. Start it with: gonext-cli start");
+    }
+    process.exit(0);
+  }
+  if (args[0] === "logs") {
+    const n = Number(parseFlag("--lines")) || 60;
+    const txt = await ctl.tailLog(n);
+    console.log(txt || `(no daemon log yet at ${ctl.LOG_FILE})`);
+    process.exit(0);
+  }
+  if (args[0] === "stop") {
+    const { killed } = await ctl.stopDaemon();
+    console.log(killed ? `[gonext-worker] stopped ${killed} daemon process(es).` : "[gonext-worker] no daemon was running.");
+    process.exit(0);
+  }
+  // start / restart both ensure exactly one daemon is running, config permitting.
+  if (args[0] === "restart") await ctl.stopDaemon();
+  // Don't spawn a daemon that would just exit(1): require a complete worker.env first.
+  const { hasWorkerConfig } = await import("./device-login.mjs");
+  if (!(await hasWorkerConfig())) {
+    console.error(
+      "[gonext-worker] not configured — run `gonext-cli login` (or `set`) first."
+    );
+    process.exit(1);
+  }
+  const r = await ctl.startDaemon();
+  if (r.started) {
+    console.log(`[gonext-worker] daemon started (pid ${r.pid}). Logs: ${ctl.LOG_FILE}`);
+  } else {
+    console.log("[gonext-worker] daemon already running — nothing to do.");
+  }
+  process.exit(0);
+}
+// Task #127, Phase 3: ensure the base chat model is downloaded + running (no GoTerminal).
+if (args[0] === "doctor") {
+  const { hasWorkerConfig } = await import("./device-login.mjs");
+  if (!(await hasWorkerConfig())) {
+    console.error("[gonext-worker] not configured — run `gonext-cli login` first.");
+    process.exit(1);
+  }
+  const { runDoctor } = await import("./model-doctor.mjs");
+  const rl0 = (await import("node:readline")).createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+  const confirm = (q, defYes) =>
+    // Non-interactive: never download GBs / start a server unattended — probe + advise only.
+    interactive
+      ? new Promise((res) =>
+          rl0.question(`  ${q} [${defYes ? "Y/n" : "y/N"}] `, (a) => {
+            const s = a.trim().toLowerCase();
+            res(s ? s === "y" || s === "yes" : Boolean(defYes));
+          })
+        )
+      : Promise.resolve(false);
+  try {
+    await runDoctor({
+      apiBase: String(process.env.GONEXT_API_BASE ?? "").trim(),
+      workerKey: String(process.env.GONEXT_WORKER_KEY ?? "").trim(),
+      log: (s) => console.log(s),
+      confirm,
+    });
+  } finally {
+    rl0.close();
+  }
+  process.exit(0);
+}
+
+const apiBase = String(process.env.GONEXT_API_BASE ?? "")
+  .trim()
+  .replace(/\/+$/, "");
+const workerKey = String(process.env.GONEXT_WORKER_KEY ?? "").trim();
+const envFileWorkerKey = String(envFileLoad.parsed?.GONEXT_WORKER_KEY ?? "").trim();
+const workerKeySource = (() => {
+  if (preloadedWorkerKey && workerKey === preloadedWorkerKey) {
+    return "process.env";
+  }
+  if (envFileWorkerKey && workerKey === envFileWorkerKey) {
+    return ENV_FILE;
+  }
+  return "unknown";
+})();
+const pollMs = 500;
+const localHealthConcurrency = 4;
+
+const CHUNK_PATH = "/api/worker/job-chunk";
+const OCR_PROMPT = "Text Recognition:";
+const OCR_MAX_TOKENS = 2048;
+const OCR_TIMEOUT_MS = 180_000;
+const OCR_DEBUG = String(process.env.GONEXT_OCR_DEBUG ?? "").trim() === "1";
+const OCR_SKIP_CORRECTION = String(process.env.GONEXT_OCR_SKIP_CORRECTION ?? "").trim() === "1";
+const OCR_CORRECT_TIMEOUT_MS = 120_000;
+// Fire-and-forget warm-up of the agent's Ollama coding model. Generous because a
+// cold load of a big/multimodal model into VRAM can take ~20s+; the request isn't
+// awaited, so a long ceiling just avoids aborting an in-progress load.
+const AGENT_WARMUP_TIMEOUT_MS = 180_000;
+// How often the background keep-warm re-asserts the coding model's keep_alive:-1.
+const AGENT_WARMUP_INTERVAL_MS = 240_000; // 4 min — under Ollama's 5-min default unload
+// OCR translation/correction is hardcoded to a managed Ollama service + model.
+// (The user-configurable "OCR translation model" chooser was removed.)
+const OCR_TRANSLATE_OLLAMA_URL = "https://ollama1.gomarsic.cc";
+const OCR_TRANSLATE_OLLAMA_MODEL = "qwen3:14b";
+// Ollama defaults num_ctx to 2048 and silently truncates longer inputs (keeping
+// only the tail), which would drop the start of a long OCR page. Pin the context
+// window to 32k so full-page/multi-paragraph OCR is corrected in one pass.
+const OCR_TRANSLATE_NUM_CTX = 32768;
+
+async function workerFetch(path, init = {}) {
+  const url = `${apiBase}${path.startsWith("/") ? path : `/${path}`}`;
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Worker-Key": workerKey,
+    ...(init.headers ?? {}),
+  };
+  return fetch(url, { ...init, headers });
+}
+
+async function ensureWorkerOk(res, context) {
+  if (res.ok) return;
+  const snippet = (await res.text().catch(() => "")).trim().slice(0, 500);
+  throw new Error(
+    `${context} failed ${res.status}${snippet ? `: ${snippet}` : ""}`
+  );
+}
+
+function assertWorkerRuntimeConfig(mode) {
+  if (!workerKey) {
+    console.error(
+      `[gonext-worker] ${mode}: missing GONEXT_WORKER_KEY. Run: gonext-cli set <workerKey> --api-base <url>`
+    );
+    process.exit(1);
+  }
+  if (!apiBase) {
+    console.error(
+      `[gonext-worker] ${mode}: missing GONEXT_API_BASE. Run: gonext-cli set <workerKey> --api-base <url>`
+    );
+    process.exit(1);
+  }
+}
+
+if (args[0] === "ws-ping-test") {
+  assertWorkerRuntimeConfig("ws-ping-test");
+  const url = `${apiBase}/api/worker/ws-ping-test`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Worker-Key": workerKey,
+    },
+    body: "{}",
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    console.error(`[gonext-worker] ws-ping-test failed ${res.status}: ${text}`);
+    if (res.status === 404 && text.includes("Cannot POST")) {
+      console.error(
+        "[gonext-worker] DEPLOY: this API does not have POST /api/worker/ws-ping-test yet. From repo root: sam build && sam deploy (or ship updated server-bundle to your Node host)."
+      );
+    }
+    process.exit(1);
+  }
+  try {
+    const parsed = JSON.parse(text);
+    console.log(
+      `[gonext-worker] ws-ping-test OK user=${parsed.userId ?? "unknown"} host=${
+        parsed.workerHostId ?? "legacy"
+      } keyfp=${parsed.workerKeyFingerprint ?? workerKeyFingerprint(workerKey)}`
+    );
+  } catch {
+    console.log("[gonext-worker] ws-ping-test OK:", text);
+  }
+  process.exit(0);
+}
+
+if (args[0] === "workspace") {
+  // Manage the local workspaces the agent may READ and EDIT code in. Registration
+  // happens HERE on the Mac (never from the web) — the registry is the security
+  // boundary for the agent's coding tools (grep/read/edit/run stay inside these roots).
+  //   gonext-cli workspace add <path> [--name <name>] [--allow-run]
+  //   gonext-cli workspace remove <path-or-name>
+  //   gonext-cli workspace list
+  const wsFile = join(homedir(), ".gonext", "workspaces.json");
+  const readWs = async () => {
+    try {
+      const raw = JSON.parse(await readFile(wsFile, "utf8"));
+      return Array.isArray(raw?.workspaces) ? raw.workspaces : [];
+    } catch {
+      return [];
+    }
+  };
+  const writeWs = async (workspaces) => {
+    await mkdir(dirname(wsFile), { recursive: true });
+    await writeFile(wsFile, JSON.stringify({ workspaces }, null, 2) + "\n");
+  };
+  const sub = args[1];
+  const { resolve } = await import("node:path");
+  const { existsSync, statSync } = await import("node:fs");
+  if (sub === "add") {
+    let p = args[2] || "";
+    if (!p) {
+      console.error("Usage: gonext-cli workspace add <path> [--name <name>] [--allow-run]");
+      process.exit(1);
+    }
+    if (p.startsWith("~/") || p === "~") p = join(homedir(), p.slice(p.length > 1 ? 2 : 1));
+    p = resolve(p);
+    if (!existsSync(p) || !statSync(p).isDirectory()) {
+      console.error(`[gonext-worker] workspace add: not a directory: ${p}`);
+      process.exit(1);
+    }
+    const nameIdx = args.indexOf("--name");
+    const name = nameIdx >= 0 && args[nameIdx + 1] ? args[nameIdx + 1] : p.split("/").filter(Boolean).pop();
+    const allowRun = args.includes("--allow-run");
+    const list = (await readWs()).filter((w) => w.path !== p);
+    list.push({ name, path: p, allowRun, addedAt: new Date().toISOString() });
+    await writeWs(list);
+    console.log(
+      `[gonext-worker] workspace registered: ${name} → ${p}` +
+        (allowRun ? " (run-commands ENABLED)" : " (run-commands disabled; add --allow-run to enable tests)")
+    );
+    process.exit(0);
+  }
+  if (sub === "remove") {
+    const key = args[2] || "";
+    const list = await readWs();
+    const next = list.filter((w) => w.path !== key && w.name !== key);
+    if (next.length === list.length) {
+      console.error(`[gonext-worker] workspace remove: no workspace matches '${key}'`);
+      process.exit(1);
+    }
+    await writeWs(next);
+    console.log(`[gonext-worker] workspace removed: ${key}`);
+    process.exit(0);
+  }
+  if (sub === "revert") {
+    // Restore the files an agent run changed: copy backups back over edits and delete
+    // created files. Uses the manifest the python tools persist per change.
+    //   gonext-cli workspace revert          → latest run
+    //   gonext-cli workspace revert <runId>  → a specific run (see backups dir)
+    const { readdirSync, existsSync: ex } = await import("node:fs");
+    const { copyFile, unlink, rmdir } = await import("node:fs/promises");
+    const backupsRoot = join(homedir(), ".gonext", "workspace-backups");
+    let runId = args[2] || "";
+    if (!runId) {
+      const runs = (() => {
+        try { return readdirSync(backupsRoot).filter((d) => !d.startsWith(".")).sort(); }
+        catch { return []; }
+      })();
+      if (runs.length === 0) {
+        console.error("[gonext-worker] workspace revert: no backup runs found.");
+        process.exit(1);
+      }
+      runId = runs[runs.length - 1];
+    }
+    const manifestPath = join(backupsRoot, runId, "manifest.json");
+    let manifest;
+    try {
+      manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    } catch {
+      console.error(`[gonext-worker] workspace revert: no manifest for run ${runId} (${manifestPath})`);
+      process.exit(1);
+    }
+    let restored = 0, deleted = 0, failed = 0;
+    for (const c of manifest?.changes ?? []) {
+      try {
+        if (c.action === "edit" && c.backup && ex(c.backup)) {
+          await copyFile(c.backup, c.path);
+          restored += 1;
+          console.log(`  restored ${c.path}`);
+        } else if (c.action === "create" && ex(c.path)) {
+          await unlink(c.path);
+          deleted += 1;
+          console.log(`  deleted  ${c.path}`);
+        } else if (c.action === "create_dir" && ex(c.path)) {
+          // rmdir only removes an EMPTY dir — a revert must never destroy content
+          // the user (or a later run) put inside the created folder afterwards.
+          await rmdir(c.path);
+          deleted += 1;
+          console.log(`  removed  ${c.path}/`);
+        }
+      } catch (err) {
+        failed += 1;
+        console.error(`  FAILED   ${c.path}: ${err.message}`);
+      }
+    }
+    console.log(
+      `[gonext-worker] workspace revert ${runId}: ${restored} restored, ${deleted} created-file(s) deleted` +
+        (failed ? `, ${failed} FAILED` : "") +
+        " (backups kept)"
+    );
+    process.exit(failed ? 1 : 0);
+  }
+  // default: list
+  const list = await readWs();
+  if (list.length === 0) {
+    console.log("[gonext-worker] no workspaces registered. Add one:\n  gonext-cli workspace add ~/Projects/my-repo --allow-run");
+  } else {
+    for (const w of list) {
+      console.log(`  ${w.name}  ${w.path}  run:${w.allowRun ? "yes" : "no"}`);
+    }
+  }
+  process.exit(0);
+}
+
+if (args[0] === "embed") {
+  // Start the MLX embeddings server (OpenAI-compatible /v1/embeddings) for the RAG
+  // feature, in the FOREGROUND of this terminal. Run it in a SEPARATE terminal from the
+  // worker (the worker keeps polling; this holds one terminal for the embed model).
+  //   gonext-cli embed --model ~/mlx-models/<embed-model> [--port 8085] [--host 127.0.0.1]
+  // Then set web Settings → Agent → RAG → "Embedding server URL" to http://<host>:<port>.
+  const flag = (name, fallback) => {
+    const i = args.indexOf(name);
+    return i >= 0 && typeof args[i + 1] === "string" ? args[i + 1] : fallback;
+  };
+  let model = flag("--model", process.env.GONEXT_EMBED_MODEL || "");
+  const port = flag("--port", process.env.GONEXT_EMBED_PORT || "8085");
+  const host = flag("--host", process.env.GONEXT_EMBED_HOST || "127.0.0.1");
+  if (!model) {
+    console.error(
+      "[gonext-worker] embed: --model is required.\n" +
+        "  Usage: gonext-cli embed --model ~/mlx-models/Qwen3-Embedding-8B-4bit-DWQ [--port 8085] [--host 127.0.0.1]\n" +
+        "  (or set GONEXT_EMBED_MODEL). Then set the RAG embedding server URL to http://<host>:<port> in web Settings."
+    );
+    process.exit(1);
+  }
+  // Expand a leading ~ to the home dir (spawn does not do shell expansion).
+  if (model.startsWith("~/") || model === "~") {
+    model = join(homedir(), model.slice(model.length > 1 ? 2 : 1));
+  }
+  const python =
+    (process.env.GONEXT_PROBE_PYTHON ?? process.env.GONEXT_MLX_LM_PYTHON ?? "").trim() ||
+    "python3";
+  const script = join(WORKER_DIR, "gonext_mlx_embed.py");
+  console.log(
+    `[gonext-worker] starting MLX embeddings server → ${python} ${script} --model ${model} --port ${port} --host ${host}`
+  );
+  const child = spawn(
+    python,
+    [script, "--model", model, "--port", String(port), "--host", String(host)],
+    { stdio: "inherit" }
+  );
+  child.on("error", (err) => {
+    console.error(`[gonext-worker] embed: failed to start python (${python}): ${err.message}`);
+    process.exit(1);
+  });
+  // Forward Ctrl-C to the child so the model unloads cleanly.
+  const stop = () => child.kill("SIGINT");
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  // Block the module from continuing to the polling loop; exit when the child exits.
+  await new Promise((resolve) => child.on("exit", (code) => resolve(code ?? 0))).then(
+    (code) => process.exit(code)
+  );
+}
+
+if (args[0] === "simulate-chat") {
+  assertWorkerRuntimeConfig("simulate-chat");
+  const reply =
+    args.slice(1).join(" ").trim() ||
+    String(process.env.GONEXT_SIMULATE_TEXT ?? "").trim() ||
+    "Simulated model reply: hello from gonext-cli simulate-chat.";
+  const jobRes = await workerFetch("/api/worker/jobs/next", { method: "POST" });
+  if (jobRes.status === 204) {
+    console.error(
+      "[gonext-worker] simulate-chat: no pending job. In the web app, send a message that returns 202 (async local chat), then run this again. Stop the normal worker so it does not claim the job first."
+    );
+    process.exit(1);
+  }
+  if (!jobRes.ok) {
+    const t = await jobRes.text().catch(() => "");
+    console.error(`[gonext-worker] simulate-chat: jobs/next failed ${jobRes.status}: ${t}`);
+    process.exit(1);
+  }
+  const job = await jobRes.json();
+  const jobId = job?.jobId;
+  if (!jobId) {
+    console.error("[gonext-worker] simulate-chat: invalid jobs/next response (missing jobId).");
+    process.exit(1);
+  }
+  const isLocalHealth =
+    job.jobType === "local_health" || job.modelKey === "local_health";
+  const isOcrJob =
+    job.jobType === "ocr" ||
+    (job.payload &&
+      typeof job.payload === "object" &&
+      typeof job.payload.ocrId === "string");
+  if (isLocalHealth || isOcrJob) {
+    await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage:
+          isLocalHealth
+            ? "simulate-chat: claimed a local_health job. Mark failed so you can retry. Queue a chat message (not Settings refresh) and stop the normal worker before simulate-chat."
+            : "simulate-chat: claimed an OCR job. Mark failed so you can retry. Queue a chat message and stop the normal worker before simulate-chat.",
+        totalTimeSeconds: 0,
+      }),
+    });
+    console.error(
+      isLocalHealth
+        ? "[gonext-worker] simulate-chat: claimed local_health instead of chat. Job marked failed. Retry with only a pending chat job."
+        : "[gonext-worker] simulate-chat: claimed OCR instead of chat. Job marked failed. Retry with only a pending chat job."
+    );
+    process.exit(1);
+  }
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  if (!runRes.ok) {
+    const errBody = await runRes.text().catch(() => "");
+    console.error(
+      `[gonext-worker] simulate-chat: mark running failed ${runRes.status}${errBody ? `: ${errBody}` : ""}`
+    );
+    process.exit(1);
+  }
+  const sliceSize = 160;
+  for (let i = 0; i < reply.length; i += sliceSize) {
+    const slice = reply.slice(i, i + sliceSize);
+    if (!slice) continue;
+    const chunkRes = await workerFetch(CHUNK_PATH, {
+      method: "POST",
+      body: JSON.stringify({ jobId, text: slice }),
+    });
+    if (!chunkRes.ok && chunkRes.status !== 204) {
+      const snippet = (await chunkRes.text().catch(() => "")).trim().slice(0, 400);
+      console.error(
+        `[gonext-worker] simulate-chat: job-chunk failed ${chunkRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+      process.exit(1);
+    }
+  }
+  const totalTimeSeconds = (Date.now() - start) / 1000;
+  const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({
+      jobStatus: "completed",
+      resultText: reply,
+      tokenCount: Math.max(1, Math.ceil(reply.length / 4)),
+      totalTimeSeconds,
+    }),
+  });
+  if (!doneRes.ok) {
+    const snippet = (await doneRes.text().catch(() => "")).trim().slice(0, 400);
+    console.error(
+      `[gonext-worker] simulate-chat: complete PATCH failed ${doneRes.status}` +
+        (snippet ? `: ${snippet}` : "")
+    );
+    process.exit(1);
+  }
+  console.log(
+    `[gonext-worker] simulate-chat OK jobId=${jobId} (${totalTimeSeconds.toFixed(2)}s, ${reply.length} chars) — same HTTP path as the real worker (API pushes worker_job_chunk / worker_job to the web app).`
+  );
+  process.exit(0);
+}
+
+assertWorkerRuntimeConfig("worker");
+
+console.log(`[gonext-worker] gonext-cli v${WORKER_VERSION}`);
+console.log(
+  `[gonext-worker] API base ${apiBase} — streaming chunks POST ${apiBase}${CHUNK_PATH} — keyfp=${workerKeyFingerprint(
+    workerKey
+  )}`
+);
+console.log(
+  `[gonext-worker] worker key ${maskWorkerKey(workerKey)} (keyfp=${workerKeyFingerprint(
+    workerKey
+  )}, source=${workerKeySource})`
+);
+
+function toOpenAIMessages(messages) {
+  return (Array.isArray(messages) ? messages : []).map((m) => {
+    if (m.role === "user" && m.attachments?.length) {
+      return {
+        role: m.role,
+        content: [
+          { type: "text", text: m.content },
+          ...m.attachments.map((a) => ({
+            type: "image_url",
+            image_url: { url: `data:${a.mimeType};base64,${a.data}` },
+          })),
+        ],
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+}
+
+function parseCompletionTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+  if (typeof usage.completion_tokens === "number") {
+    return usage.completion_tokens;
+  }
+  if (typeof usage.output_tokens === "number") {
+    return usage.output_tokens;
+  }
+  return null;
+}
+
+function shouldRetryWithoutUsage(err) {
+  const msg =
+    err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+  return msg.includes("stream_options") || msg.includes("include_usage");
+}
+
+async function runChatJob(job) {
+  const { jobId, payload } = job;
+  if (!payload || !Array.isArray(payload.messages)) {
+    throw new Error("Invalid chat payload: messages array is missing.");
+  }
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  if (!runRes.ok) {
+    const errBody = await runRes.text().catch(() => "");
+    throw new Error(
+      `mark running failed ${runRes.status}${errBody ? `: ${errBody}` : ""}`
+    );
+  }
+
+  const client = new OpenAI({
+    baseURL: payload.baseURL,
+    apiKey: payload.apiKey || "ollama",
+    maxRetries: 0,
+    timeout: 90_000,
+  });
+
+  let buf = "";
+  let flushTimer = null;
+  let fullText = "";
+  /** Chains debounced chunk POSTs so we never PATCH `completed` while a chunk POST is still in flight. */
+  let flushTail = Promise.resolve();
+
+  /** Batch streamed text: fewer HTTPS round-trips to the API than a 12ms debounce per flush. */
+  const CHUNK_DEBOUNCE_MS = 80;
+  const CHUNK_MAX_BUF = 6144;
+
+  const flushChunks = async () => {
+    const t = buf;
+    buf = "";
+    if (!t) return;
+    const res = await workerFetch(CHUNK_PATH, {
+      method: "POST",
+      body: JSON.stringify({ jobId, text: t }),
+    });
+    if (!res.ok && res.status !== 204) {
+      const snippet = (await res.text().catch(() => "")).trim().slice(0, 400);
+      const url = `${apiBase}${CHUNK_PATH}`;
+      const benign409 =
+        res.status === 409 && snippet.includes('"jobStatus":"completed"');
+      if (!benign409) {
+        console.error(
+          `[gonext-worker] job-chunk POST failed status=${res.status} url=${url} jobId=${jobId}` +
+            (snippet ? ` response=${snippet}` : "")
+        );
+      }
+      if (res.status === 404) {
+        if (snippet.includes("Cannot POST")) {
+          console.error(
+            "[gonext-worker] DEPLOY: Lambda/API still runs old Express without POST /api/worker/job-chunk. From repo: cd api && npm ci && sam build && sam deploy — or publish the latest bundled handler so execute-api serves current routes."
+          );
+        } else {
+          console.error(
+            '[gonext-worker] hint: JSON {"error":"Job not found"} = Dynamo lookup failed (wrong worker user vs job owner). Otherwise redeploy API.'
+          );
+        }
+      }
+    }
+  };
+
+  const enqueueText = (s) => {
+    if (!s) return;
+    fullText += s;
+    buf += s;
+    if (buf.length >= CHUNK_MAX_BUF) {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      flushTail = flushTail.then(() => flushChunks()).catch((err) => {
+        console.error("[gonext-worker] chunk flush error:", err);
+      });
+      return;
+    }
+    if (!flushTimer) {
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flushTail = flushTail.then(() => flushChunks()).catch((err) => {
+          console.error("[gonext-worker] chunk flush error:", err);
+        });
+      }, CHUNK_DEBOUNCE_MS);
+    }
+  };
+
+  try {
+    const streamRequest = {
+      model: payload.modelId,
+      messages: toOpenAIMessages(payload.messages),
+      stream: true,
+      temperature: 0,
+    };
+    const stream = await client.chat.completions
+      .create({
+        ...streamRequest,
+        stream_options: { include_usage: true },
+      })
+      .catch(async (e) => {
+        if (!shouldRetryWithoutUsage(e)) {
+          throw e;
+        }
+        return client.chat.completions.create(streamRequest);
+      });
+
+    let tokenCount = 0;
+    let completionTokensFromUsage = null;
+    let isStartThinking = false;
+    let isEndThinking = false;
+
+    for await (const chunk of stream) {
+      const usageTokens = parseCompletionTokens(chunk.usage);
+      if (usageTokens !== null) {
+        completionTokensFromUsage = usageTokens;
+      }
+      const delta = chunk.choices[0]?.delta;
+      const content = delta?.content ?? "";
+      const reasoningContent = delta?.reasoning_content;
+      tokenCount += 1;
+
+      if (reasoningContent) {
+        if (!isStartThinking) {
+          isStartThinking = true;
+          enqueueText("<think>");
+        }
+        enqueueText(reasoningContent);
+      } else {
+        if (isStartThinking && !isEndThinking) {
+          isEndThinking = true;
+          enqueueText("</think>");
+        }
+        if (content) {
+          enqueueText(content);
+        }
+      }
+    }
+
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    await flushTail;
+    await flushChunks();
+
+    logModelResponseToWorker(jobId, payload.modelId, fullText);
+
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: fullText,
+        tokenCount:
+          completionTokensFromUsage !== null
+            ? completionTokensFromUsage
+            : Math.max(1, tokenCount),
+        totalTimeSeconds,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete PATCH jobId=${jobId}`);
+    console.log(`[gonext-worker] completed ${jobId} (${totalTimeSeconds.toFixed(1)}s)`);
+  } catch (e) {
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    await flushTail;
+    await flushChunks().catch(() => {});
+    const message = e instanceof Error ? e.message : String(e);
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] failed status PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed ${jobId}:`, message);
+  }
+}
+
+function categorizeHttpStatus(status) {
+  if (status >= 200 && status < 300) return "2xx";
+  if (status >= 300 && status < 400) return "3xx";
+  if (status >= 400 && status < 500) return "4xx";
+  if (status >= 500 && status < 600) return "5xx";
+  return "network_error";
+}
+
+function probeVerdict(status, expectedStatus) {
+  if (expectedStatus === undefined || expectedStatus === null) {
+    return status >= 200 && status < 300 ? "pass" : "fail";
+  }
+  const list = Array.isArray(expectedStatus) ? expectedStatus : [expectedStatus];
+  return list.includes(status) ? "pass" : "fail";
+}
+
+/** tool_only / agentic summary: ask the selected model to interpret the measured result. */
+async function summarizeProbeWithModel(payload, result) {
+  const client = new OpenAI({
+    baseURL: payload.agentBaseURL,
+    apiKey: payload.agentApiKey || "local",
+    maxRetries: 0,
+    timeout: 60_000,
+  });
+  const lines = [
+    `HTTP probe result for ${result.request.method} ${result.request.url}`,
+  ];
+  if (result.response) {
+    lines.push(
+      `Status: ${result.response.status} ${result.response.statusText} (${result.category})`,
+      `Latency: ${result.response.latencyMs} ms`,
+      `Body (first chars): ${result.response.bodySnippet || "(empty)"}`
+    );
+  } else {
+    lines.push(`No response — ${result.category}: ${result.error ?? "unknown error"}`);
+  }
+  lines.push(
+    `Verdict: ${result.verdict}.`,
+    "In 1-2 sentences, say whether the endpoint is healthy and what this status means."
+  );
+  const completion = await client.chat.completions.create({
+    model: payload.agentModelId,
+    messages: [
+      {
+        role: "system",
+        content: "You are an API health assistant. Be concise and factual.",
+      },
+      { role: "user", content: lines.join("\n") },
+    ],
+    temperature: 0,
+    max_tokens: 200,
+  });
+  return completion.choices?.[0]?.message?.content?.trim() || "";
+}
+
+/** Deterministic HTTP measurement: real status/latency/headers/body, no model. */
+async function performHttpMeasurement(params) {
+  let response = null;
+  let category;
+  let errorMessage;
+  const reqStart = Date.now();
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), params.timeoutMs);
+  try {
+    const res = await fetch(params.url, {
+      method: params.method,
+      headers: params.headers,
+      body: params.sendBody ? params.body : undefined,
+      signal: ac.signal,
+      redirect: "manual",
+    });
+    const latencyMs = Date.now() - reqStart;
+    let text = "";
+    try {
+      text = await res.text();
+    } catch {
+      text = "";
+    }
+    const SNIP = 2048;
+    const bodySnippet =
+      text.length > SNIP
+        ? `${text.slice(0, SNIP)} …[truncated ${text.length - SNIP} chars]`
+        : text;
+    const resHeaders = {};
+    res.headers.forEach((v, k) => {
+      resHeaders[k] = v;
+    });
+    category = categorizeHttpStatus(res.status);
+    response = {
+      status: res.status,
+      statusText: res.statusText || "",
+      ok: res.status >= 200 && res.status < 300,
+      latencyMs,
+      headers: resHeaders,
+      bodySnippet,
+      bodyBytes: Buffer.byteLength(text),
+    };
+  } catch (err) {
+    const aborted =
+      ac.signal.aborted ||
+      (err && typeof err === "object" && err.name === "AbortError");
+    category = aborted ? "timeout" : "network_error";
+    errorMessage = aborted
+      ? `Request timed out after ${params.timeoutMs} ms`
+      : err instanceof Error
+      ? err.message
+      : String(err);
+  } finally {
+    clearTimeout(timer);
+  }
+  return { response, category, errorMessage };
+}
+
+/**
+ * Spawn a child process, feed it stdin, and call onLine for each NDJSON stdout
+ * line as they arrive. Resolves when the process exits cleanly; rejects on
+ * non-zero exit or timeout. stderr is collected and appended to error messages.
+ */
+function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine, extraEnv, abortSignal, onTimeout) {
+  return new Promise((resolve, reject) => {
+    const spawnOpts = { stdio: ["pipe", "pipe", "pipe"] };
+    if (extraEnv && Object.keys(extraEnv).length > 0) {
+      spawnOpts.env = { ...process.env, ...extraEnv };
+    }
+    const child = spawn(cmd, cmdArgs, spawnOpts);
+    let stderr = "";
+    let lineBuffer = "";
+    let timedOut = false;
+    let aborted = false;
+    let closed = false;
+    let timerLive = true;
+    // On the time budget: with no onTimeout handler (probe/legacy) this is a hard cap —
+    // kill immediately. With a handler (task #81, interactive terminal) ask the user
+    // whether to keep waiting; the child keeps running/streaming during the ~60s prompt.
+    // "Keep waiting" disables the cap for the rest of the run; No / no-answer kills it.
+    const fireTimeout = async () => {
+      if (!timerLive || closed || aborted) return;
+      if (typeof onTimeout !== "function") {
+        timedOut = true;
+        timerLive = false;
+        child.kill("SIGKILL");
+        return;
+      }
+      let extend = false;
+      try {
+        extend = await onTimeout();
+      } catch {
+        extend = false;
+      }
+      if (closed || aborted || !timerLive) return; // finished/cancelled during the prompt
+      if (extend) {
+        timerLive = false; // ignore the time budget for the rest of this run
+        return;
+      }
+      timedOut = true;
+      timerLive = false;
+      child.kill("SIGKILL");
+    };
+    const timer = setTimeout(fireTimeout, timeoutMs);
+    // User-requested cancel (gonext Ctrl+C): kill the Python agent so it stops burning
+    // steps/tokens. On close we resolve cleanly (not reject) — the caller checks the
+    // cancel flag and leaves the job in its already-"cancelled" state.
+    const onAbort = () => {
+      if (aborted) return;
+      aborted = true;
+      child.kill("SIGKILL");
+    };
+    if (abortSignal) {
+      if (abortSignal.aborted) onAbort();
+      else abortSignal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout.on("data", (d) => {
+      lineBuffer += d.toString("utf8");
+      const parts = lineBuffer.split("\n");
+      lineBuffer = parts.pop() ?? "";
+      for (const line of parts) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          try {
+            onLine(JSON.parse(trimmed));
+          } catch {
+            /* ignore non-JSON */
+          }
+        }
+      }
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    child.on("error", (e) => {
+      closed = true;
+      timerLive = false;
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      closed = true;
+      timerLive = false;
+      clearTimeout(timer);
+      if (abortSignal) abortSignal.removeEventListener?.("abort", onAbort);
+      // Drain any remaining buffered line
+      const remaining = lineBuffer.trim();
+      if (remaining) {
+        try {
+          onLine(JSON.parse(remaining));
+        } catch {
+          /* ignore */
+        }
+      }
+      if (aborted) {
+        resolve(); // cancelled by the user — a clean stop, not an error
+        return;
+      }
+      if (timedOut) {
+        reject(new Error(`agent chat timed out after ${timeoutMs} ms`));
+        return;
+      }
+      if (code !== 0) {
+        reject(
+          new Error(
+            `agent chat exited ${code}${stderr.trim() ? `: ${stderr.trim().slice(0, 500)}` : ""}`
+          )
+        );
+        return;
+      }
+      resolve();
+    });
+    child.stdin.write(stdinStr);
+    child.stdin.end();
+  });
+}
+
+/** Run a child process, feed it stdin, resolve with stdout (rejects on non-zero/timeout). */
+function runProcessWithStdin(cmd, cmdArgs, stdinStr, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, cmdArgs, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(new Error(`probe agent timed out after ${timeoutMs} ms`));
+        return;
+      }
+      if (code !== 0) {
+        reject(
+          new Error(
+            `probe agent exited ${code}${stderr.trim() ? `: ${stderr.trim().slice(0, 500)}` : ""}`
+          )
+        );
+        return;
+      }
+      resolve(stdout);
+    });
+    child.stdin.write(stdinStr);
+    child.stdin.end();
+  });
+}
+
+/**
+ * Agentic summary: drive a smolagents agent (on the selected local model) over
+ * the worker's measurement. The agent does not re-fetch — the worker's Node
+ * measurement stays the source of truth. Throws so callers can fall back.
+ */
+async function summarizeProbeAgentic(payload, result) {
+  const python =
+    (process.env.GONEXT_PROBE_PYTHON ?? process.env.GONEXT_MLX_LM_PYTHON ?? "")
+      .trim() || "python3";
+  const scriptPath = join(WORKER_DIR, "gonext_probe_agent.py");
+  const input = JSON.stringify({
+    request: result.request,
+    measurement: result.response,
+    category: result.category,
+    error: result.error ?? null,
+    agentBaseURL: payload?.agentBaseURL ?? "",
+    agentApiKey: payload?.agentApiKey ?? "",
+    agentModelId: payload?.agentModelId ?? "",
+  });
+  const timeoutMs =
+    (Number.isFinite(payload?.timeoutMs) ? payload.timeoutMs : 15_000) + 120_000;
+  const stdout = await runProcessWithStdin(python, [scriptPath], input, timeoutMs);
+  const parsed = JSON.parse(stdout);
+  const summary =
+    typeof parsed?.agentSummary === "string" ? parsed.agentSummary.trim() : "";
+  if (!summary) {
+    throw new Error(parsed?.error || "agent produced no summary");
+  }
+  return summary;
+}
+
+async function runHttpProbeJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running http_probe jobId=${jobId}`);
+  try {
+    const method = String(payload?.method || "GET").toUpperCase();
+    const url = String(payload?.url || "");
+    if (!url) throw new Error("http_probe payload missing url.");
+    const headers =
+      payload?.headers && typeof payload.headers === "object" ? payload.headers : {};
+    const sendBody =
+      !["GET", "HEAD"].includes(method) &&
+      typeof payload?.body === "string" &&
+      payload.body.length > 0;
+    const timeoutMs =
+      Number.isFinite(payload?.timeoutMs) && payload.timeoutMs > 0
+        ? payload.timeoutMs
+        : 15_000;
+    const requestBodyBytes = sendBody ? Buffer.byteLength(payload.body) : 0;
+    const measureParams = { method, url, headers, sendBody, body: payload?.body, timeoutMs };
+    const agentMode = payload?.agentMode === "agentic" ? "agentic" : "tool_only";
+
+    // The worker's Node fetch is the authoritative measurement for both modes.
+    const measurement = await performHttpMeasurement(measureParams);
+    const { response, category, errorMessage } = measurement;
+
+    const status = response?.status ?? 0;
+    const verdict =
+      category === "timeout" || category === "network_error"
+        ? "fail"
+        : probeVerdict(status, payload?.expectedStatus);
+
+    const result = {
+      request: { method, url, headers, bodyBytes: requestBodyBytes },
+      response,
+      category,
+      verdict,
+      agentMode,
+      agentModel: payload?.agentModel || payload?.agentModelId || "",
+      ...(errorMessage ? { error: errorMessage } : {}),
+    };
+
+    if (agentMode === "agentic") {
+      try {
+        result.agentSummary = await summarizeProbeAgentic(payload, result);
+      } catch (e) {
+        // smolagents/Python unavailable: fall back to a direct model summary.
+        try {
+          result.agentSummary = `${await summarizeProbeWithModel(payload, result)} (agentic fallback)`;
+        } catch {
+          result.agentSummary = `(Agentic summary unavailable: ${
+            e instanceof Error ? e.message : String(e)
+          })`;
+        }
+      }
+    } else {
+      try {
+        result.agentSummary = await summarizeProbeWithModel(payload, result);
+      } catch (e) {
+        result.agentSummary = `(Model summary unavailable: ${
+          e instanceof Error ? e.message : String(e)
+        })`;
+      }
+    }
+
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: JSON.stringify(result),
+        tokenCount: 1,
+        totalTimeSeconds,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete http_probe jobId=${jobId}`);
+    console.log(
+      `[gonext-worker] completed http_probe ${jobId} (${totalTimeSeconds.toFixed(
+        1
+      )}s) ${method} ${url} -> ${category}/${verdict}`
+    );
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] http_probe fail PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed http_probe ${jobId}:`, message);
+  }
+}
+
+function resolveImageExtension(mimeType, fileName) {
+  const byMime = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tiff",
+    "image/heic": ".heic",
+    "image/heif": ".heif",
+  };
+  const byMimeExt = byMime[String(mimeType ?? "").toLowerCase()];
+  if (byMimeExt) return byMimeExt;
+  const ext = fileName ? extname(String(fileName)).toLowerCase() : "";
+  return ext || ".png";
+}
+
+function resolveOcrModelPath(modelFromJob) {
+  const fromJob = String(modelFromJob ?? "").trim();
+  if (fromJob) {
+    const expanded = fromJob.replace(/^~(?=\/)/, homedir());
+    if (expanded.startsWith("/")) {
+      return expanded;
+    }
+    return join(homedir(), "mlx-models", expanded);
+  }
+  const fromEnv = String(process.env.GONEXT_OCR_MODEL_PATH ?? "").trim();
+  if (fromEnv) {
+    return fromEnv.replace(/^~(?=\/)/, homedir());
+  }
+  return join(homedir(), "mlx-models", "GLM-OCR-bf16");
+}
+
+function normalizeOcrOutput(output) {
+  let text = String(output ?? "").replace(/\r\n/g, "\n");
+  const afterAssistant = text.includes("<|assistant|>")
+    ? text.split("<|assistant|>").pop()
+    : "";
+  if (afterAssistant && afterAssistant.trim()) {
+    text = afterAssistant;
+  }
+  const escapedPrompt = OCR_PROMPT.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  text = text
+    .replace(/<\|[^|>]+\|>/g, " ")
+    .replace(/<think>[\s\S]*?<\/think>/gi, " ")
+    .replace(/<think>|<\/think>/gi, " ")
+    .replace(new RegExp(escapedPrompt, "gi"), " ")
+    .replace(/(?:^|[\s/\\])nothink\b/gi, " ")
+    .replace(/\\n/g, "\n");
+  const lines = text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .filter((line) => !line.startsWith("<frozen runpy>:"))
+    .filter(
+      (line) =>
+        !line.startsWith("Files:") &&
+        !line.startsWith("Prompt:") &&
+        !line.startsWith("Generation:") &&
+        !line.startsWith("Calling `python -m mlx_vlm.generate") &&
+        !line.startsWith("Peak memory:") &&
+        !line.startsWith("=======") &&
+        line !== "<think>" &&
+        line !== "</think>" &&
+        line !== "<think></think>" &&
+        line !== "No text generated for this prompt"
+    );
+  return lines.join("\n").trim();
+}
+
+function normalizeCorrection(raw, originalText) {
+  let text = String(raw ?? "").replace(/\r\n/g, "\n");
+  // Strip common mlx_lm.generate noise lines
+  const lines = text
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0)
+    .filter((l) =>
+      !l.startsWith("=======") &&
+      !l.startsWith("Prompt:") &&
+      !l.startsWith("Generation:") &&
+      !l.startsWith("Peak memory:") &&
+      !l.startsWith("Files:") &&
+      !l.startsWith("<frozen runpy>:")
+    );
+  const result = lines.join("\n").trim();
+  // Safety: if correction came back empty or too short, keep original
+  if (!result || result.length < originalText.length * 0.3) {
+    return originalText;
+  }
+  return result;
+}
+
+/**
+ * Call an Ollama host's native chat endpoint (POST {base}/api/chat) for text
+ * correction/translation, e.g. base "https://ollama1.gomarsic.cc" model "qwen3:14b".
+ * `think:false` suppresses reasoning models' <think> preamble so we get clean text.
+ */
+const OCR_CORRECT_SYSTEM_PROMPT =
+  "You are a text correction assistant. Fix grammar and language errors in the " +
+  "provided text while preserving the original meaning and language. " +
+  "Return only the corrected text without any explanation.";
+
+/**
+ * Call an OpenAI-compatible chat endpoint (POST {base}/v1/chat/completions) for text
+ * correction — e.g. an MLX `mlx_lm.server` (the agent model server) at
+ * http://127.0.0.1:8080/v1 serving qwen3:14b. Strips any <think> preamble.
+ */
+async function correctOcrTextViaOpenAI(extractedText, base, model) {
+  const b = base.replace(/\/+$/, "");
+  const url = /\/v1$/.test(b) ? `${b}/chat/completions` : `${b}/v1/chat/completions`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      stream: false,
+      temperature: 0,
+      // Qwen3 (and other reasoning models) emit a <think> trace by default. Over the
+      // OpenAI /v1 API there's no `think:false` flag, so use Qwen3's `/no_think` SOFT
+      // SWITCH (honored by its chat template, same as the agent loop) to suppress it —
+      // otherwise the model spends its whole token budget reasoning and returns no
+      // corrected text (seen live: correction was a no-op, chars unchanged). Generous
+      // max_tokens so a long OCR page isn't truncated.
+      max_tokens: 4096,
+      messages: [
+        { role: "system", content: `${OCR_CORRECT_SYSTEM_PROMPT}\n/no_think` },
+        { role: "user", content: `Text:\n${extractedText}` },
+      ],
+    }),
+    signal: AbortSignal.timeout(OCR_CORRECT_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new Error(`MLX ${b} returned ${res.status}`);
+  }
+  const json = await res.json();
+  let corrected = json?.choices?.[0]?.message?.content?.trim() || "";
+  // Strip a <think> trace if `/no_think` wasn't honored: closed pairs, a template-opened
+  // leading …</think>, and a trailing UNCLOSED <think> (truncated by max_tokens).
+  corrected = corrected
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/^[\s\S]*?<\/think>/i, "")
+    .replace(/<think>[\s\S]*$/i, "")
+    .trim();
+  return normalizeCorrection(corrected, extractedText);
+}
+
+async function correctOcrTextViaOllama(extractedText, base, model) {
+  const systemPrompt = OCR_CORRECT_SYSTEM_PROMPT;
+  const res = await fetch(`${base.replace(/\/+$/, "")}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      stream: false,
+      think: false,
+      options: { temperature: 0, num_ctx: OCR_TRANSLATE_NUM_CTX },
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: `Text:\n${extractedText}` },
+      ],
+    }),
+    signal: AbortSignal.timeout(OCR_CORRECT_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama ${base} returned ${res.status}`);
+  }
+  const json = await res.json();
+  let corrected = json?.message?.content?.trim() || "";
+  // Safety net for reasoning models (qwen3) if `think:false` isn't honored:
+  // drop any <think>…</think> preamble before normalizing.
+  corrected = corrected.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+  return normalizeCorrection(corrected, extractedText);
+}
+
+async function correctOcrText(extractedText, correction) {
+  if (OCR_SKIP_CORRECTION) {
+    console.log("[gonext-worker] OCR correction skipped (GONEXT_OCR_SKIP_CORRECTION=1)");
+    return extractedText;
+  }
+
+  // The API resolves the backend from the user's settings and bakes {backend,url,model}
+  // into the job payload — DEFAULT is "mlx" (the agent MLX model server, OpenAI /v1).
+  // Absent (older jobs / no settings) → fall back to the legacy managed-Ollama default.
+  const backend = correction?.backend === "mlx" ? "mlx" : "ollama";
+  const url = (correction?.url || "").trim() || OCR_TRANSLATE_OLLAMA_URL;
+  const model = (correction?.model || "").trim() || OCR_TRANSLATE_OLLAMA_MODEL;
+  console.log(
+    `[gonext-worker] OCR correction via ${backend} ${url} model=${model}`
+  );
+  console.log(`[gonext-worker] OCR correction input: ${extractedText.slice(0, 300)}`);
+  try {
+    const corrected =
+      backend === "mlx"
+        ? await correctOcrTextViaOpenAI(extractedText, url, model)
+        : await correctOcrTextViaOllama(extractedText, url, model);
+    console.log(`[gonext-worker] OCR correction output: ${corrected.slice(0, 300)}`);
+    console.log(
+      `[gonext-worker] OCR correction done: ${extractedText.length} → ${corrected.length} chars`
+    );
+    return corrected;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.warn(
+      `[gonext-worker] OCR correction (${backend}) failed (using raw OCR text): ${msg.slice(0, 200)}`
+    );
+    return extractedText;
+  }
+}
+
+async function runMlxVlmGenerate(modelPath, imagePath) {
+  const sharedArgs = [
+    "--model",
+    modelPath,
+    "--prompt",
+    OCR_PROMPT,
+    "--image",
+    imagePath,
+    "--temperature",
+    "0.0",
+    "--max-tokens",
+    String(OCR_MAX_TOKENS),
+  ];
+  try {
+    const result = await execFile(
+      "python3",
+      ["-m", "mlx_vlm.generate", ...sharedArgs],
+      {
+        timeout: OCR_TIMEOUT_MS,
+        maxBuffer: 10 * 1024 * 1024,
+      }
+    );
+    return { ...result, invocation: "python3 -m mlx_vlm.generate" };
+  } catch (primaryError) {
+    const stderr =
+      primaryError && typeof primaryError === "object" && "stderr" in primaryError
+        ? String(primaryError.stderr ?? "").toLowerCase()
+        : "";
+    const message =
+      primaryError instanceof Error ? primaryError.message.toLowerCase() : "";
+    const missingLegacyModule =
+      stderr.includes("no module named mlx_vlm.generate") ||
+      message.includes("no module named mlx_vlm.generate");
+    if (!missingLegacyModule) {
+      throw primaryError;
+    }
+    const result = await execFile(
+      "python3",
+      ["-m", "mlx_vlm", "generate", ...sharedArgs],
+      {
+        timeout: OCR_TIMEOUT_MS,
+        maxBuffer: 10 * 1024 * 1024,
+      }
+    );
+    return { ...result, invocation: "python3 -m mlx_vlm generate" };
+  }
+}
+
+function compactPreview(text, max = 800) {
+  const normalized = String(text ?? "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!normalized) {
+    return "(empty)";
+  }
+  if (normalized.length <= max) {
+    return normalized;
+  }
+  return `${normalized.slice(0, max)} …[truncated ${normalized.length - max} chars]`;
+}
+
+async function runOcrJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running OCR jobId=${jobId}`);
+  try {
+    if (!payload || typeof payload !== "object") {
+      throw new Error("Invalid OCR payload.");
+    }
+    const attachment = payload.attachment;
+    const mimeType = typeof attachment?.mimeType === "string" ? attachment.mimeType : "";
+    const data = typeof attachment?.data === "string" ? attachment.data : "";
+    const s3Object =
+      attachment && typeof attachment === "object" ? attachment.s3Object : undefined;
+    const s3GetUrl =
+      s3Object && typeof s3Object.getUrl === "string" ? s3Object.getUrl.trim() : "";
+    const sourceLabel = s3GetUrl
+      ? `s3://${s3Object?.bucket ?? "unknown"}/${s3Object?.key ?? "unknown"}`
+      : "inline_base64";
+    const ocrModel =
+      typeof payload.model === "string" && payload.model.trim()
+        ? payload.model.trim()
+        : "GLM-OCR-bf16";
+    const name = typeof attachment?.name === "string" ? attachment.name : "";
+    if (!mimeType.startsWith("image/")) {
+      throw new Error("OCR job attachment must be an image.");
+    }
+    if (!data && !s3GetUrl) {
+      throw new Error("OCR job attachment is empty.");
+    }
+    let bytes;
+    if (s3GetUrl) {
+      const dlRes = await fetch(s3GetUrl, { method: "GET" });
+      if (!dlRes.ok) {
+        throw new Error(
+          `Failed to download OCR image from S3 (${dlRes.status}).`
+        );
+      }
+      const arr = await dlRes.arrayBuffer();
+      bytes = Buffer.from(arr);
+    } else {
+      bytes = Buffer.from(data, "base64");
+    }
+    if (!bytes.length) {
+      throw new Error("OCR job attachment data is not valid.");
+    }
+    console.log(`[gonext-worker] OCR source jobId=${jobId} ${sourceLabel}`);
+
+    const tempDir = await mkdtemp(join(tmpdir(), "gonext-ocr-worker-"));
+    let extractedText = "";
+    try {
+      const imagePath = join(
+        tempDir,
+        `input${resolveImageExtension(mimeType, name)}`
+      );
+      await writeFile(imagePath, bytes);
+      const modelPath = resolveOcrModelPath(ocrModel);
+      const { stdout, stderr, invocation } = await runMlxVlmGenerate(
+        modelPath,
+        imagePath
+      );
+      if (OCR_DEBUG) {
+        console.log(
+          `[gonext-worker][ocr-debug] jobId=${jobId} invocation=${invocation} model=${modelPath} image=${imagePath} source=${
+            sourceLabel
+          } stdout=${compactPreview(stdout)} stderr=${compactPreview(stderr)}`
+        );
+      }
+      extractedText = normalizeOcrOutput(stdout);
+      if (!extractedText) {
+        throw new Error(
+          `OCR returned empty text for this image. invocation=${invocation} stdout=${compactPreview(stdout)} stderr=${compactPreview(stderr)}`
+        );
+      }
+    } finally {
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+    // Post-process: correct grammar/language via the backend the API resolved from the
+    // user's settings (payload.correction = {backend,url,model}; default MLX = the agent
+    // model server). Falls back to raw OCR text on any error so the job never fails here.
+    extractedText = await correctOcrText(extractedText, payload.correction);
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: extractedText,
+        tokenCount: Math.max(1, Math.ceil(extractedText.length / 4)),
+        totalTimeSeconds,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete OCR jobId=${jobId}`);
+    console.log(
+      `[gonext-worker] completed OCR ${jobId} (${totalTimeSeconds.toFixed(1)}s) model=${ocrModel}`
+    );
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] OCR fail PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed OCR ${jobId}:`, message);
+  }
+}
+
+const TRANSCRIBE_TIMEOUT_MS =
+  Number(process.env.GONEXT_TRANSCRIBE_TIMEOUT_MS ?? "300000") || 300000;
+
+function resolveWorkerPython() {
+  return (
+    (process.env.GONEXT_PROBE_PYTHON ?? process.env.GONEXT_MLX_LM_PYTHON ?? "").trim() ||
+    "python3"
+  );
+}
+
+/** Spawn a Python script, write `input` to stdin, capture stdout/stderr. */
+function runPythonCapture(python, args, input, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn(python, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        /* ignore */
+      }
+      resolve({ code: null, stdout, stderr, timedOut: true });
+    }, timeoutMs);
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (e) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ code: null, stdout, stderr: stderr + String(e), timedOut: false });
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ code, stdout, stderr, timedOut: false });
+    });
+    try {
+      child.stdin.write(input);
+      child.stdin.end();
+    } catch {
+      /* the error/close handler will settle */
+    }
+  });
+}
+
+async function runTranscribeJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running transcribe jobId=${jobId}`);
+  const tempDir = await mkdtemp(join(tmpdir(), "gonext-transcribe-"));
+  try {
+    if (!payload || typeof payload !== "object") {
+      throw new Error("Invalid transcribe payload.");
+    }
+    const audio = payload.audio;
+    const mimeType = typeof audio?.mimeType === "string" ? audio.mimeType : "";
+    const s3Object = audio && typeof audio === "object" ? audio.s3Object : undefined;
+    const s3GetUrl =
+      s3Object && typeof s3Object.getUrl === "string" ? s3Object.getUrl.trim() : "";
+    const model =
+      typeof payload.model === "string" && payload.model.trim()
+        ? payload.model.trim()
+        : "whisper-large-v3-turbo";
+    const language =
+      typeof payload.language === "string" ? payload.language.trim() : "";
+    if (!mimeType.startsWith("audio/")) {
+      throw new Error("Transcribe job attachment must be audio.");
+    }
+    if (!s3GetUrl) {
+      throw new Error("Transcribe job is missing the audio download URL.");
+    }
+    const dlRes = await fetch(s3GetUrl, { method: "GET" });
+    if (!dlRes.ok) {
+      throw new Error(`Failed to download audio from S3 (${dlRes.status}).`);
+    }
+    const bytes = Buffer.from(await dlRes.arrayBuffer());
+    if (!bytes.length) {
+      throw new Error("Downloaded audio is empty.");
+    }
+    const audioPath = join(tempDir, "input.wav");
+    await writeFile(audioPath, bytes);
+
+    const python = resolveWorkerPython();
+    const scriptPath = join(WORKER_DIR, "gonext_transcribe.py");
+    const { code, stdout, stderr, timedOut } = await runPythonCapture(
+      python,
+      [scriptPath],
+      JSON.stringify({ audioPath, model, language: language || undefined }),
+      TRANSCRIBE_TIMEOUT_MS
+    );
+    if (timedOut) {
+      throw new Error("Transcription timed out.");
+    }
+    if (code !== 0) {
+      const reason = String(stderr ?? "").split("\n")[0]?.trim() || "error";
+      const hint =
+        reason === "lib-missing"
+          ? "Whisper library not installed. Run: pip install mlx-whisper"
+          : reason === "model-missing"
+            ? `Whisper model not downloaded. Run: hf download mlx-community/${model}`
+            : reason === "audio-error"
+              ? "Could not decode the recorded audio."
+              : "Transcription failed.";
+      throw new Error(`${hint} (${compactPreview(stderr)})`);
+    }
+    let text = "";
+    try {
+      const parsed = JSON.parse(String(stdout ?? "").trim() || "{}");
+      text = typeof parsed.text === "string" ? parsed.text.trim() : "";
+    } catch {
+      throw new Error(`Transcription returned malformed output: ${compactPreview(stdout)}`);
+    }
+    if (!text) {
+      throw new Error("Transcription returned empty text.");
+    }
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: text,
+        tokenCount: Math.max(1, Math.ceil(text.length / 4)),
+        totalTimeSeconds,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete transcribe jobId=${jobId}`);
+    console.log(
+      `[gonext-worker] completed transcribe ${jobId} (${totalTimeSeconds.toFixed(1)}s) model=${model}`
+    );
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] transcribe fail PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed transcribe ${jobId}:`, message);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+// —— Ollama coding-model keep-warm ——————————————————————————————————————————————
+// Ollama evicts idle models (default OLLAMA_KEEP_ALIVE=5m), so a cold agent step
+// blocks ~20s+ while llama-server pages the weights into VRAM. Instead of warming on
+// EVERY question (noisy, redundant), we remember the coding model from agent jobs and
+// re-assert a keep_alive:-1 load on a BACKGROUND INTERVAL so it stays resident between
+// questions. The agent talks to Ollama over /v1 (which ignores keep_alive), so we hit
+// the NATIVE /api/generate (no prompt = load-only, returns once the model is resident).
+// Best-effort throughout: a non-Ollama coding server just 404s and it's swallowed.
+let _warmCoding = null; // { root, model }
+let _warmTimer = null;
+let _warmLoggedOk = false;
+
+function _warmupPing(quiet) {
+  if (!_warmCoding) return;
+  const { root, model } = _warmCoding;
+  const url = `${root}/api/generate`;
+  fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model, keep_alive: -1 }),
+    signal: AbortSignal.timeout(AGENT_WARMUP_TIMEOUT_MS),
+  })
+    .then((res) => {
+      if (!res.ok) {
+        console.log(`[gonext-worker] agent warm-up HTTP ${res.status} → ${url} model=${model}`);
+      } else if (!quiet || !_warmLoggedOk) {
+        // Quiet interval pings only log the first success per model; a fresh/changed
+        // model always logs so you can see it warm.
+        console.log(`[gonext-worker] agent warm-up ok (model loading/resident) → ${url} model=${model}`);
+        _warmLoggedOk = true;
+      }
+    })
+    .catch((err) => {
+      const reason =
+        err?.name === "TimeoutError" ? "still loading in background" : err?.message || "unreachable";
+      console.log(`[gonext-worker] agent warm-up skipped (${reason}) → ${url}`);
+    });
+}
+
+// ─── Coding-backend resolution (task #117, folded into #123 Part B) ──────────────────
+// ONE answer to "which coding backend is this job using?", for the two decisions THIS
+// process makes before python starts: keep an Ollama model warm, and fetch the
+// OpenAI-compatible API key. The answer is passed down as `codingBackend` so python
+// doesn't re-derive it and can't disagree.
+//
+// The reference implementation is _resolve_coding_backend() in gonext_agent_chat.py —
+// it is pure and carries the offline resolution table (tests/test_backend_resolution.py).
+// Keep this rule in step with it: explicit kind wins → Ollama probe → remote ⇒ openai →
+// local. The probe runs BEFORE the remote rule so a remote Ollama box stays "ollama".
+
+// root → { value, until }. A YES is cached long (a box doesn't stop being Ollama), a NO
+// only briefly: "not Ollama" and "the probe failed" are indistinguishable here, so caching
+// a failure would strand a box that was merely booting/unreachable for one job.
+const _ollamaProbeCache = new Map();
+const _PROBE_TTL_YES_MS = 30 * 60_000;
+const _PROBE_TTL_NO_MS = 60_000;
+
+async function _probeIsOllama(baseURL) {
+  const root = String(baseURL || "").replace(/\/+$/, "").replace(/\/v1$/i, "");
+  if (!root) return false;
+  const hit = _ollamaProbeCache.get(root);
+  if (hit && hit.until > Date.now()) return hit.value;
+  let isOllama = false;
+  try {
+    // Ollama answers GET / with the plain-text banner "Ollama is running".
+    const res = await fetch(root, {
+      headers: { "User-Agent": "gonext-worker/1.0" },
+      signal: AbortSignal.timeout(6000),
+    });
+    isOllama = res.ok && /ollama/i.test((await res.text()).slice(0, 200));
+  } catch {
+    isOllama = false; // unreachable/TLS/404 → not provably Ollama
+  }
+  _ollamaProbeCache.set(root, {
+    value: isOllama,
+    until: Date.now() + (isOllama ? _PROBE_TTL_YES_MS : _PROBE_TTL_NO_MS),
+  });
+  return isOllama;
+}
+
+function _isLocalCodingUrl(baseURL) {
+  let host = "";
+  try {
+    host = new URL(String(baseURL || "")).hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return true; // unparseable → we are certainly not talking to a paid remote
+  }
+  if (!host) return true;
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (["localhost", "0.0.0.0", "::", "::1"].includes(host)) return true;
+  if (/^127(\.\d{1,3}){3}$/.test(host)) return true;
+  if (/^(10(\.\d{1,3}){3}|192\.168(\.\d{1,3}){2}|172\.(1[6-9]|2\d|3[01])(\.\d{1,3}){2}|169\.254(\.\d{1,3}){2})$/.test(host))
+    return true;
+  if (host.includes(":") && (host.startsWith("fe80:") || /^f[cd]/.test(host))) return true;
+  if (/\.(local|localdomain|lan|home|internal)$/.test(host)) return true;
+  // A dotless hostname ("mac-studio", "ollama1") is a LAN box: a public host always has a
+  // dot, and erring this way only ever means "don't expect an API key here".
+  return !host.includes(".") && !host.includes(":");
+}
+
+/** Resolve to "ollama" | "openai" | "local". `kind` is the user's Settings choice
+ *  ("ollama" | "openai" | "" = Auto). Only Auto costs a probe. */
+async function resolveCodingBackend(kind, baseURL) {
+  if (kind === "ollama" || kind === "openai" || kind === "local") return kind;
+  if (await _probeIsOllama(baseURL)) return "ollama";
+  return _isLocalCodingUrl(baseURL) ? "local" : "openai";
+}
+
+/**
+ * Remember the agent's Ollama coding model (from a claimed agent_chat job) and keep it
+ * resident via a background interval. Warms IMMEDIATELY only when the model is first
+ * seen or CHANGES — not on every question — so repeat questions don't re-warm/re-log.
+ */
+function trackCodingModelForWarmup(codingBaseURL, codingModelId) {
+  if (!codingBaseURL || !codingModelId) return;
+  // codingBaseURL is normalized to …/v1 for OpenAI-compat; strip it to reach the
+  // Ollama root where /api/generate lives.
+  const root = String(codingBaseURL).replace(/\/+$/, "").replace(/\/v1$/i, "");
+  const changed = !_warmCoding || _warmCoding.root !== root || _warmCoding.model !== codingModelId;
+  _warmCoding = { root, model: codingModelId };
+  if (changed) {
+    _warmLoggedOk = false;
+    _warmupPing(false); // warm the newly-seen/changed model now so the next question isn't cold
+  }
+  if (!_warmTimer) {
+    // 4 min — under Ollama's 5-min default unload, so the model stays resident even
+    // if a proxy strips keep_alive. unref() so this timer never blocks worker exit.
+    _warmTimer = setInterval(() => _warmupPing(true), AGENT_WARMUP_INTERVAL_MS);
+    if (typeof _warmTimer.unref === "function") _warmTimer.unref();
+  }
+}
+
+async function runAgentChatJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  // User-requested cancel (gonext Ctrl+C): the REPL marks the job "cancelled" via the
+  // API; a poll below (and the job-chunk 409 path) trips this controller, which kills
+  // the Python agent. `cancelled` is checked at the finish so we DON'T overwrite the
+  // "cancelled" status with completed/failed.
+  const cancelAc = new AbortController();
+  let cancelled = false;
+  // Task #108: the user's Coding backend setting ("ollama" | "openai" | "" = Auto).
+  const codingKind = ["ollama", "openai", "local"].includes(payload?.codingKind)
+    ? payload.codingKind
+    : "";
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running agent_chat jobId=${jobId}`);
+  // Task #117/#123: `codingKind` above is the SETTING, not the answer — resolve the actual
+  // backend ONCE here and let both decisions below, plus python, read that one value.
+  // AFTER the "running" PATCH on purpose: an Auto config costs a probe (~6s worst case,
+  // then cached), and the REPL shouldn't watch a claimed job sit in "queued" for it.
+  const codingBackend = await resolveCodingBackend(codingKind, payload?.codingBaseURL ?? "");
+  console.log(
+    `[gonext-worker] agent job ${jobId}: coding backend ${codingBackend}` +
+      ` (kind=${codingKind || "auto"}, ${payload?.codingBaseURL || "no coding url"})`
+  );
+  // Remember this job's Ollama coding model and keep it resident via a background
+  // interval. Only warms now if the model is new/changed — repeat questions rely on
+  // the interval, so we don't re-warm (or re-log) on every question. The warm-up uses
+  // Ollama's native /api/generate, so it runs ONLY for an actual Ollama backend: on
+  // anything else that endpoint doesn't exist, and on a cloud one we'd be pinging a paid
+  // API every 4 minutes (which an Auto+cloud config did until #117 was fixed — the old
+  // gate only skipped an EXPLICIT openai kind).
+  if (codingBackend === "ollama") {
+    trackCodingModelForWarmup(payload?.codingBaseURL ?? "", payload?.codingModelId ?? "");
+  }
+
+  let buf = "";
+  let flushTimer = null;
+  let fullText = "";
+  let flushTail = Promise.resolve();
+  const CHUNK_DEBOUNCE_MS = 80;
+  const CHUNK_MAX_BUF = 6144;
+
+  const flushChunks = async () => {
+    const t = buf;
+    buf = "";
+    if (!t) return;
+    const res = await workerFetch(CHUNK_PATH, {
+      method: "POST",
+      body: JSON.stringify({ jobId, text: t }),
+    });
+    if (!res.ok && res.status !== 204) {
+      const snippet = (await res.text().catch(() => "")).trim().slice(0, 400);
+      const cancelledNow =
+        res.status === 409 && snippet.includes('"jobStatus":"cancelled"');
+      if (cancelledNow) cancelAc.abort(); // REPL cancelled mid-run → stop the Python agent
+      const benign409 =
+        res.status === 409 &&
+        (snippet.includes('"jobStatus":"completed"') || cancelledNow);
+      if (!benign409) {
+        console.error(
+          `[gonext-worker] agent_chat job-chunk POST failed status=${res.status} jobId=${jobId}` +
+            (snippet ? ` response=${snippet}` : "")
+        );
+      }
+    }
+  };
+
+  const enqueueText = (s) => {
+    if (!s) return;
+    fullText += s;
+    buf += s;
+    if (buf.length >= CHUNK_MAX_BUF) {
+      if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+      flushTail = flushTail.then(() => flushChunks()).catch((err) => {
+        console.error("[gonext-worker] agent_chat chunk flush error:", err);
+      });
+      return;
+    }
+    if (!flushTimer) {
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flushTail = flushTail.then(() => flushChunks()).catch((err) => {
+          console.error("[gonext-worker] agent_chat chunk flush error:", err);
+        });
+      }, CHUNK_DEBOUNCE_MS);
+    }
+  };
+
+  console.log(
+    `[gonext-worker] agent_chat ${jobId} baseURL=${payload?.agentBaseURL ?? "(none)"} modelId=${payload?.agentModelId ?? "(none)"}`
+  );
+  try {
+    const python =
+      (process.env.GONEXT_PROBE_PYTHON ?? process.env.GONEXT_MLX_LM_PYTHON ?? "")
+        .trim() || "python3";
+    const scriptPath = join(WORKER_DIR, "gonext_agent_chat.py");
+
+    // Workspace scope depends on WHERE the job came from (task #75). The `gonext`
+    // terminal always sends its launch cwd as activeWorkspace; the web app never does —
+    // that's the discriminator.
+    //   • Terminal: the real `gonext-cli workspace add` registry + that cwd.
+    //   • Web agent chat: ONE isolated temp scratch folder — NOT the Mac's registered
+    //     project folders. Inheriting them leaked their paths into the web prompt and
+    //     let terminal state drive web routing. run_command stays off (not a code repo).
+    const terminalActiveWs = String(payload?.activeWorkspace ?? "").trim();
+    let jobWorkspaces;
+    let jobActiveWorkspace;
+    if (terminalActiveWs) {
+      jobWorkspaces = await readFile(join(homedir(), ".gonext", "workspaces.json"), "utf8")
+        .then((raw) => {
+          const parsed = JSON.parse(raw);
+          return Array.isArray(parsed?.workspaces) ? parsed.workspaces : [];
+        })
+        .catch(() => []);
+      jobActiveWorkspace = terminalActiveWs;
+    } else {
+      const webWork = join(homedir(), ".gonext", "web-agent-work");
+      await mkdir(webWork, { recursive: true }).catch(() => {});
+      jobWorkspaces = [{ name: "web", path: webWork, allowRun: false }];
+      jobActiveWorkspace = webWork;
+    }
+
+    // Task #108: for an OpenAI-compatible coder, fetch the API key from a dedicated
+    // worker-authed endpoint (NOT the job payload/Mongo doc — secret hygiene) and inject
+    // it into python stdin only. Keyed off the RESOLVED backend (#117), so an Auto config
+    // pointing at a cloud endpoint now gets its key: it used to require the explicit
+    // "openai" kind, and python's `coding_api_key or agent_api_key` fallback then
+    // authenticated a cloud provider with the LOCAL agent key → 401.
+    let codingApiKey = "";
+    if (codingBackend === "openai") {
+      try {
+        const kr = await workerFetch("/api/worker/coding-key");
+        if (kr.ok) {
+          const kj = await kr.json().catch(() => ({}));
+          if (typeof kj?.apiKey === "string") codingApiKey = kj.apiKey;
+        }
+      } catch {
+        /* best-effort — python falls back to a keyless call, which the endpoint may 401 */
+      }
+    }
+
+    const input = JSON.stringify({
+      messages: payload?.messages ?? [],
+      agentBaseURL: payload?.agentBaseURL ?? "",
+      agentApiKey: payload?.agentApiKey ?? "",
+      agentModelId: payload?.agentModelId ?? "",
+      codingBaseURL: payload?.codingBaseURL ?? "",
+      codingModelId: payload?.codingModelId ?? "",
+      codingKind,
+      // The resolved backend (#117): python trusts this instead of probing again, so the
+      // key fetch above and python's streaming / repair / step-budget branches can't
+      // disagree about what this endpoint is. Python re-resolves only if it ends up on a
+      // DIFFERENT url than the one judged here (its no-model-id fallback to the chat model).
+      codingBackend,
+      codingApiKey,
+      // Task #107: when true, python emits a {type:code_response} event per code-model
+      // call so the worker persists the full raw text to Mongo.
+      saveFullResponse: payload?.saveFullResponse === true,
+      // Dedicated SEARCH model (#105): when set, web_search synthesizes its results into a
+      // cited answer with this model instead of returning raw read pages. Empty = no synth.
+      searchBaseURL: payload?.searchBaseURL ?? "",
+      searchModelId: payload?.searchModelId ?? "",
+      // SearXNG metasearch URL ("Agent Search Server", web Settings). Empty = python falls
+      // back to the GONEXT_SEARXNG_URL env (or keyless DDG only).
+      searxngUrl: payload?.searxngUrl ?? "",
+      tools: payload?.tools ?? ["http_request"],
+      // 0 = "not explicitly set": python defaults to 5, but may auto-raise to 12 when
+      // workspaces are registered. Passing a literal 5 here would look user-set and
+      // block that bump.
+      maxSteps: payload?.maxSteps ?? 0,
+      // run_command policy (web Settings → Agent). Both optional: empty = allow every
+      // command except the always-blocked sudo/su. runAllowlist (non-empty) = opt-in
+      // lockdown to exactly those runners; runDenylist = extra blocks. Accept whatever
+      // the API sends (list or comma/space string); python re-parses either shape.
+      runAllowlist: payload?.runAllowlist ?? [],
+      runDenylist: payload?.runDenylist ?? [],
+      // Interactive command-approval gate: the jobId lets python register a pending
+      // approval + poll for the user's Yes/No via the API; interactiveApproval is the
+      // REPL's "I can show a picker" signal (else python keeps hard-blocking, as on web).
+      jobId,
+      interactiveApproval: payload?.interactiveApproval === true,
+      // Session opt-in (task #80): auto-extend past the step budget without re-prompting
+      // (the REPL sets this once the user picks "yes, don't ask again").
+      alwaysExtendOnMaxStep: payload?.alwaysExtendOnMaxStep === true,
+      // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
+      autoTest: payload?.autoTest === true,
+      // Deploy target chosen via the terminal /server picker (task #69). Host/user only.
+      deployServer: payload?.deployServer ?? null,
+      // Max web_search + fetch_url calls the agent may make per task (user-configurable
+      // in web Settings → Agent). Default 10; past it the retrieval tools refuse.
+      researchBudget: payload?.researchBudget ?? 10,
+      // Tool-invocation mode for the agent: "code" (default, python CodeAgent) or
+      // "toolcall" (structured JSON tool calls). Passed through only; the API/web can
+      // set payload.agentToolMode to A/B — default keeps current behavior.
+      agentToolMode: payload?.agentToolMode ?? "code",
+      // For the create_pdf tool: the worker key lets the Python tool ask the API
+      // to presign an S3 upload, so no AWS creds ever live on the worker machine.
+      apiBaseURL: apiBase,
+      workerKey,
+      // send_email tool: the user configures their own email API (e.g. a Lambda) in
+      // web Settings. The tool is only registered when emailEnabled + URL + body
+      // template are set, and always previews before sending (confirm required).
+      emailEnabled: payload?.emailEnabled ?? false,
+      emailApiUrl: payload?.emailApiUrl ?? "",
+      emailApiMethod: payload?.emailApiMethod ?? "POST",
+      emailApiHeaders: payload?.emailApiHeaders ?? "",
+      emailBodyTemplate: payload?.emailBodyTemplate ?? "",
+      emailFrom: payload?.emailFrom ?? "",
+      emailAllowList: payload?.emailAllowList ?? "",
+      // RAG tools (download/unzip/index/search over a user's ZIP-at-URL). Only enabled
+      // + registered when ragEnabled + AWS creds present. The worker talks to the user's
+      // OWN S3 bucket directly with these creds (boto3), NOT via presigned URLs.
+      ragEnabled: payload?.ragEnabled ?? false,
+      ragS3Location: payload?.ragS3Location ?? "",
+      ragAwsRegion: payload?.ragAwsRegion ?? "",
+      ragAwsAccessKeyId: payload?.ragAwsAccessKeyId ?? "",
+      ragAwsSecretAccessKey: payload?.ragAwsSecretAccessKey ?? "",
+      ragEmbedModel: payload?.ragEmbedModel ?? "",
+      ragEmbedUrl: payload?.ragEmbedUrl ?? "",
+      ragTopK: payload?.ragTopK ?? 6,
+      // RAG storage backend for this folder (task #97): "local" = on disk under ~/.gonext
+      // (per-folder, no S3 creds), else "cloud" (the user's S3). Terminal sends the folder's
+      // choice; web never sets it → "cloud". python re-validates and defaults to cloud.
+      ragMode: payload?.ragMode === "local" ? "local" : "cloud",
+      // Workspaces the agent may read/edit/test code in (see the terminal-vs-web split
+      // computed above): the real registry for the terminal, a lone temp folder for web.
+      workspaces: jobWorkspaces,
+      // download_file/unzip_file output lands here (a registered workspace; python
+      // re-validates). Terminal = its launch cwd; web = the temp scratch folder.
+      activeWorkspace: jobActiveWorkspace,
+    });
+    // Agent run time budget (task #81). Default 60 min; user-configurable in web Settings
+    // (agentTimeoutMinutes → payload.agentTimeoutMs). Multi-step ReAct on a 14B/31B with a
+    // cold prompt cache — or a remote Ollama box slow-cold-loading a big model — can run
+    // for many minutes per step, so a generous budget is normal. On expiry the TERMINAL
+    // (interactive) asks the user whether to keep waiting (onAgentTimeout below); "yes"
+    // ignores the budget for the rest of the run. WEB has no picker AND a hard WS deadline
+    // (1_860_000 ms), so it's capped at 30 min and just aborts — our clean timeout error
+    // then reaches the user instead of a generic WS timeout. On a hard stop the python
+    // child is SIGKILLed (shows as a BrokenPipeError in the model server log — expected).
+    // Liveness during long model calls comes from the python heartbeat (a keepalive step
+    // chunk every 45s), not from this cap.
+    const DEFAULT_AGENT_TIMEOUT_MS = 3_600_000; // 1 hour
+    const WEB_AGENT_TIMEOUT_CAP_MS = 1_800_000; // stay under the web WS deadline
+    const isInteractiveTimeout = payload?.interactiveApproval === true;
+    const requestedTimeoutMs =
+      Number.isFinite(payload?.agentTimeoutMs) && payload.agentTimeoutMs > 0
+        ? payload.agentTimeoutMs
+        : DEFAULT_AGENT_TIMEOUT_MS;
+    const timeoutMs = isInteractiveTimeout
+      ? requestedTimeoutMs
+      : Math.min(requestedTimeoutMs, WEB_AGENT_TIMEOUT_CAP_MS);
+
+    let inThink = false;
+    let finalText = "";
+    let answerStreamed = false; // an answer_stream delta already delivered the visible text
+    // Task #83: running total of prompt tokens sent to the agent CODE model. Updated on
+    // each python "tokens" event, persisted to the job doc (Mongo) so the REPL can show
+    // it live and it survives on the completed job.
+    let latestCodeTokens = 0;
+    // Task #84: peak single-request prompt-token count seen this turn (not the sum).
+    let latestMaxCodeTokens = 0;
+    // Task #104: running total of OUTPUT (completion) tokens the CODE model generated this
+    // turn. Persisted to the job doc; the REPL folds this turn's total into the lifetime
+    // per-workspace + per-(user, coding-URL) counters at completion.
+    let latestCodeOutputTokens = 0;
+    // Raw model-stream tokens (event.type === "stream") are Python code + `Thought:`
+    // prose + <code>/<|"|> fragments. The web Thought panel renders reasoning as
+    // markdown, which turns `#`-prefixed code comments into <h1> headings and
+    // swallows the tag fragments. Wrap only the raw stream in a fenced code block so
+    // it renders verbatim; `step` labels stay outside the fence as normal prose.
+    // Tilde fences (~~~) avoid colliding with any ``` the model itself emits.
+    let inStreamFence = false;
+    const closeStreamFence = () => {
+      if (inStreamFence) {
+        inStreamFence = false;
+        enqueueText("\n~~~\n\n");
+      }
+    };
+
+    // The create_pdf tool uses WeasyPrint, whose Homebrew libs (pango/cairo/gobject)
+    // live in /opt/homebrew/lib (Apple Silicon) or /usr/local/lib (Intel). macOS doesn't
+    // search those by default, so ctypes can't dlopen them. Inject the path for the child
+    // so users don't have to set DYLD_FALLBACK_LIBRARY_PATH themselves.
+    let pdfEnv;
+    if (process.platform === "darwin") {
+      const existing = process.env.DYLD_FALLBACK_LIBRARY_PATH ?? "";
+      const brewLibs = ["/opt/homebrew/lib", "/usr/local/lib"];
+      const merged = [existing, ...brewLibs].filter(Boolean).join(":");
+      pdfEnv = { DYLD_FALLBACK_LIBRARY_PATH: merged };
+    }
+
+    // Poll our own job status during the run so a REPL Ctrl+C (which marks the job
+    // "cancelled" via the API) actually stops the Python agent within ~1.5s, instead of
+    // only being noticed on the next chunk flush (which can be 45s apart during a long
+    // model call). The job-chunk 409 path (flushChunks) is the backup signal.
+    const cancelPoll = setInterval(async () => {
+      if (cancelAc.signal.aborted) return;
+      try {
+        const r = await workerFetch(`/api/worker/jobs/${jobId}`);
+        if (r.ok) {
+          const j = await r.json().catch(() => ({}));
+          if (j?.jobStatus === "cancelled") {
+            cancelled = true;
+            cancelAc.abort();
+          }
+        }
+      } catch {
+        /* transient poll error — try again next tick */
+      }
+    }, 1500);
+    cancelAc.signal.addEventListener("abort", () => { cancelled = true; }, { once: true });
+
+    // Task #81: when the time budget is reached in the TERMINAL, ask the user whether to
+    // keep waiting instead of just aborting. Reuses the #67 approval plumbing
+    // (approval-request → poll approvalDecision) with a __TIMEOUT__:: sentinel the REPL
+    // recognizes and renders as a Yes/No picker (auto-No at 60s). Returns true = keep
+    // waiting (disable the cap), false = stop. Only wired for interactive jobs (web never
+    // reaches here — it isn't passed as onTimeout).
+    const onAgentTimeout = async () => {
+      if (!isInteractiveTimeout || !jobId) return false;
+      const approvalId = `timeout-${Date.now()}`;
+      const mins = Math.round(timeoutMs / 60000);
+      const command = `__TIMEOUT__::The agent has run for ${mins} min (the time budget). Keep waiting?`;
+      try {
+        const r = await workerFetch(`/api/worker/jobs/${jobId}/approval-request`, {
+          method: "POST",
+          body: JSON.stringify({ id: approvalId, command }),
+        });
+        if (!r.ok) return false;
+      } catch {
+        return false;
+      }
+      // Poll for the user's Yes/No up to ~65s (the REPL auto-answers No at 60s).
+      const deadline = Date.now() + 65_000;
+      while (Date.now() < deadline) {
+        if (cancelAc.signal.aborted) return false;
+        await new Promise((r) => setTimeout(r, 1500));
+        try {
+          const r = await workerFetch(`/api/worker/jobs/${jobId}`);
+          if (r.ok) {
+            const j = await r.json().catch(() => ({}));
+            const dec = j?.approvalDecision;
+            if (dec && dec.id === approvalId) return dec.allow === true;
+          }
+        } catch {
+          /* transient poll error — keep trying */
+        }
+      }
+      return false; // no answer in time → treat as No (stop)
+    };
+
+    try {
+    await runProcessWithStreamingStdout(python, [scriptPath], input, timeoutMs, (event) => {
+      if (event.type === "log" && typeof event.text === "string") {
+        console.log(`[gonext-agent] ${event.text}`);
+      } else if (event.type === "stream" && typeof event.text === "string") {
+        // Live model token stream (the agent's Thought / reasoning as it generates).
+        // Goes inside the same <think> block as the step summaries, but RAW — no
+        // "\n\n" separator, so the tokens concatenate into flowing text. Wrapped in
+        // a code fence (opened lazily on the first stream token) so the web viewer
+        // renders it verbatim instead of as markdown.
+        if (!inThink) {
+          inThink = true;
+          enqueueText("<think>");
+        }
+        if (!inStreamFence) {
+          inStreamFence = true;
+          enqueueText("~~~\n");
+        }
+        enqueueText(event.text);
+      } else if (event.type === "step" && typeof event.text === "string") {
+        closeStreamFence();
+        if (!inThink) {
+          inThink = true;
+          enqueueText("<think>");
+        }
+        enqueueText(event.text + "\n\n");
+      } else if (event.type === "answer_stream" && typeof event.text === "string") {
+        // Live delta of the FINAL user-facing answer (the plain-chat fast path streams
+        // its reply as it generates, instead of blocking for the whole thing) — this is
+        // the actual answer, NOT reasoning, so it must stay OUTSIDE <think> (wrapping it
+        // would hide it in the web's collapsed Thinking panel instead of the live main
+        // answer bubble). Close any open think/stream fence first in case a prior step
+        // left one dangling.
+        closeStreamFence();
+        if (inThink) {
+          inThink = false;
+          enqueueText("</think>");
+        }
+        enqueueText(event.text);
+        answerStreamed = true;
+      } else if (event.type === "tokens" && Number.isFinite(event.codeInput)) {
+        // Prompt tokens sent to the agent CODE model (tasks #83 accumulated + #84 peak).
+        // Persist both to the job doc so they're in Mongo and the REPL can render them
+        // live. Steps are seconds apart, so a fire-and-forget PATCH per event is cheap;
+        // it only touches agentCodeTokens/agentMaxCodeTokens (never resultText/jobStatus),
+        // so it can't race the chunk/completed writes.
+        const nextTotal = Math.max(latestCodeTokens, event.codeInput);
+        const nextMax = Number.isFinite(event.codeMax)
+          ? Math.max(latestMaxCodeTokens, event.codeMax)
+          : latestMaxCodeTokens;
+        // Task #104: output tokens climb monotonically across the turn too.
+        const nextOut = Number.isFinite(event.codeOutput)
+          ? Math.max(latestCodeOutputTokens, event.codeOutput)
+          : latestCodeOutputTokens;
+        if (
+          nextTotal !== latestCodeTokens ||
+          nextMax !== latestMaxCodeTokens ||
+          nextOut !== latestCodeOutputTokens
+        ) {
+          latestCodeTokens = nextTotal;
+          latestMaxCodeTokens = nextMax;
+          latestCodeOutputTokens = nextOut;
+          workerFetch(`/api/worker/jobs/${jobId}`, {
+            method: "PATCH",
+            body: JSON.stringify({
+              agentCodeTokens: latestCodeTokens,
+              agentMaxCodeTokens: latestMaxCodeTokens,
+              agentOutputTokens: latestCodeOutputTokens,
+            }),
+          }).catch(() => {});
+        }
+      } else if (event.type === "code_response" && typeof event.text === "string") {
+        // Task #107: the user's Save-Full-Response toggle is on — persist this code-model
+        // response's full raw text to Mongo. Fire-and-forget; never blocks the turn.
+        workerFetch(`/api/worker/agent-response`, {
+          method: "POST",
+          body: JSON.stringify({
+            jobId,
+            step: Number.isFinite(event.step) ? event.step : 0,
+            text: event.text,
+            inputTokens: Number.isFinite(event.inputTokens) ? event.inputTokens : 0,
+            outputTokens: Number.isFinite(event.outputTokens) ? event.outputTokens : 0,
+            codingUrl: payload?.codingBaseURL ?? "",
+          }),
+        }).catch(() => {});
+      } else if (event.type === "final" && typeof event.text === "string") {
+        closeStreamFence();
+        if (inThink) {
+          inThink = false;
+          enqueueText("</think>");
+        }
+        finalText = event.text;
+        // If the answer was already delivered live via answer_stream deltas, its text is
+        // ALREADY in resultText — appending it again here would duplicate the whole reply
+        // (streamed once, then dumped again in full). Only append when nothing streamed it.
+        if (!answerStreamed) {
+          enqueueText(event.text);
+        }
+      }
+    }, pdfEnv, cancelAc.signal, isInteractiveTimeout ? onAgentTimeout : undefined);
+    } finally {
+      clearInterval(cancelPoll);
+    }
+
+    // User cancelled mid-run: the Python child was SIGKILLed and the job is already
+    // "cancelled" in the store. Leave it there — do NOT PATCH completed/failed (which
+    // would resurrect a finished status) and skip the final chunk flush (it'd 409).
+    if (cancelled || cancelAc.signal.aborted) {
+      if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+      console.log(`[gonext-worker] agent_chat ${jobId} cancelled by user`);
+      return;
+    }
+
+    closeStreamFence();
+    if (inThink) {
+      enqueueText("</think>");
+    }
+
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    await flushTail;
+    await flushChunks();
+
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        // When the answer streamed live (answer_stream), completed resultText must stay
+        // an EXACT EXTENSION of the chunk accumulation: the REPL renders the final poll
+        // by flushing resultText.slice(<chars already shown>), so replacing the stream
+        // with the shorter bare answer here made short plain replies render cut
+        // mid-word ("Hello! How"). Only when nothing streamed is the deduped finalText
+        // the whole story.
+        resultText: answerStreamed ? fullText : finalText || fullText,
+        tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
+        ...(latestCodeTokens > 0 ? { agentCodeTokens: latestCodeTokens } : {}),
+        ...(latestMaxCodeTokens > 0 ? { agentMaxCodeTokens: latestMaxCodeTokens } : {}),
+        ...(latestCodeOutputTokens > 0 ? { agentOutputTokens: latestCodeOutputTokens } : {}),
+        totalTimeSeconds,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete agent_chat PATCH jobId=${jobId}`);
+    console.log(`[gonext-worker] completed agent_chat ${jobId} (${totalTimeSeconds.toFixed(1)}s)`);
+  } catch (e) {
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    // A cancel that raced into the catch (e.g. the kill surfaced as an error before the
+    // aborted-close path): the job is already "cancelled" — don't overwrite with failed.
+    if (cancelled || cancelAc.signal.aborted) {
+      console.log(`[gonext-worker] agent_chat ${jobId} cancelled by user`);
+      return;
+    }
+    await flushTail;
+    await flushChunks().catch(() => {});
+    const message = e instanceof Error ? e.message : String(e);
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] agent_chat fail PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed agent_chat ${jobId}:`, message);
+  }
+}
+
+function normalizeBaseUrl(raw) {
+  return typeof raw === "string" ? raw.trim().replace(/\/+$/, "") : "";
+}
+
+/**
+ * "Load Models" (task #44): probe the agent coding-model server's model list. Tries the
+ * OpenAI-compatible /v1/models (MLX + Ollama both serve it) and falls back to Ollama's
+ * /api/tags. The server is on the user's network, so only this worker can reach it. The
+ * job's resultText is JSON {models:[...]} the web parses into checkboxes.
+ */
+async function runListModelsJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running list_models jobId=${jobId}`);
+  try {
+    const base = normalizeBaseUrl(payload?.url).replace(/\/v1$/i, "");
+    if (!base) throw new Error("No coding-model URL provided.");
+    const models = new Set();
+    // 1) OpenAI-compatible /v1/models → { data: [{ id }] }
+    try {
+      const r = await fetch(`${base}/v1/models`, { method: "GET" });
+      if (r.ok) {
+        const j = await r.json().catch(() => ({}));
+        for (const m of Array.isArray(j?.data) ? j.data : []) {
+          if (typeof m?.id === "string" && m.id.trim()) models.add(m.id.trim());
+        }
+      }
+    } catch {
+      /* try the Ollama shape next */
+    }
+    // 2) Ollama /api/tags → { models: [{ name }] }
+    if (models.size === 0) {
+      const r = await fetch(`${base}/api/tags`, { method: "GET" });
+      if (r.ok) {
+        const j = await r.json().catch(() => ({}));
+        for (const m of Array.isArray(j?.models) ? j.models : []) {
+          if (typeof m?.name === "string" && m.name.trim()) models.add(m.name.trim());
+        }
+      }
+    }
+    const list = Array.from(models).sort();
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: JSON.stringify({ models: list }),
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete list_models jobId=${jobId}`);
+    console.log(`[gonext-worker] list_models ${jobId}: ${list.length} model(s) from ${base}`);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: `Could not list models: ${message}`,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    }).catch(() => {});
+    console.error(`[gonext-worker] failed list_models ${jobId}:`, message);
+  }
+}
+
+function normalizeOpenAiV1Root(raw) {
+  const base = normalizeBaseUrl(raw);
+  if (!base) return "";
+  return /\/v1$/i.test(base) ? base : `${base}/v1`;
+}
+
+function sourceLabelFromBase(base) {
+  try {
+    return new URL(base).host || base;
+  } catch {
+    return base;
+  }
+}
+
+function expandHomePath(rawPath) {
+  const v = String(rawPath ?? "").trim();
+  if (!v) return "";
+  return v.replace(/^~(?=\/)/, homedir());
+}
+
+async function checkModelPathExists(rawPath) {
+  const inputPath = String(rawPath ?? "").trim();
+  const resolvedPath = expandHomePath(inputPath);
+  if (!resolvedPath) {
+    return { path: inputPath, resolvedPath: "", exists: false };
+  }
+  try {
+    const st = await stat(resolvedPath);
+    return { path: inputPath, resolvedPath, exists: st.isDirectory() || st.isFile() };
+  } catch {
+    return { path: inputPath, resolvedPath, exists: false };
+  }
+}
+
+/** Log assistant text to stdout; cap size so huge replies do not flood the terminal. */
+function logModelResponseToWorker(jobId, modelId, text) {
+  const max = 12000;
+  const n = text.length;
+  const body = n <= max ? text : `${text.slice(0, max)}\n… [log truncated: ${n - max} more chars]`;
+  console.log(
+    `[gonext-worker] model reply job=${jobId} model=${modelId} chars=${n}:\n${body}`
+  );
+}
+
+async function checkOllamaTags(rawBase) {
+  // Tolerate a base that already includes the endpoint (users sometimes paste the
+  // full `.../api/tags` URL) so we don't fetch `.../api/tags/api/tags` → 404.
+  const base = normalizeBaseUrl(rawBase).replace(/\/(?:api\/tags|api|v1)$/i, "");
+  const endpoint = `${base}/api/tags`;
+  try {
+    // Bounded so an unreachable/slow host fails fast (a hung fetch would exceed
+    // the client's local-health wait and leave the status dot stuck "pending").
+    const res = await fetch(endpoint, {
+      method: "GET",
+      signal: AbortSignal.timeout(4000),
+    });
+    if (!res.ok) return { online: false, endpoint, models: [] };
+    const j = await res.json();
+    const source = sourceLabelFromBase(base);
+    const models = (j.models ?? []).map((m) => {
+      const name = m.name ?? m.model ?? "model";
+      return {
+        id: `${name}@@${source}`,
+        name: `${name} (${source})`,
+        value: `ollama:${name}@@${encodeURIComponent(base)}`,
+      };
+    });
+    return { online: true, endpoint, models };
+  } catch {
+    return { online: false, endpoint, models: [] };
+  }
+}
+
+/**
+ * Discover the mlx_lm.server processes actually running on this machine by
+ * parsing `ps` output. Returns deduped `[{ port, modelPath }]` so the model
+ * dropdown reflects live servers instead of a hand-maintained port list.
+ * mlx_lm.server defaults to port 8080 when `--port` is omitted. macOS only.
+ */
+async function discoverMlxServers() {
+  if (platform() !== "darwin") return [];
+  let stdout = "";
+  try {
+    ({ stdout } = await execFile("ps", ["-Ao", "args="], {
+      maxBuffer: 8 * 1024 * 1024,
+    }));
+  } catch {
+    return [];
+  }
+  const byPort = new Map();
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    // Match `mlx_lm.server` or `mlx_lm server` (python -m mlx_lm server).
+    if (!/mlx_lm[.\s]server\b/.test(line)) continue;
+    // Ignore our own grep/ps invocations that happen to mention the string.
+    if (/\bgrep\b/.test(line)) continue;
+    const portMatch = line.match(/--port(?:=|\s+)(\d{2,5})/);
+    const port = portMatch ? parseInt(portMatch[1], 10) : 8080;
+    if (!(port > 0)) continue;
+    const modelMatch = line.match(/--model(?:=|\s+)(\S+)/);
+    const modelPath = modelMatch ? modelMatch[1] : "";
+    if (!byPort.has(port)) byPort.set(port, { port, modelPath });
+  }
+  return [...byPort.values()];
+}
+
+async function checkOpenAiModels(base, apiKey, source) {
+  const endpoint = `${base}/models`;
+  const headers = {};
+  if (apiKey?.trim()) {
+    headers.Authorization = `Bearer ${apiKey.trim()}`;
+  }
+  const hostSourceId =
+    typeof source?.workerHostId === "string" ? source.workerHostId.trim() : "";
+  const hostSourceLabel =
+    typeof source?.hostName === "string" ? source.hostName.trim() : "";
+  const sourcePort = typeof source?.port === "number" ? source.port : null;
+  try {
+    const res = await fetch(endpoint, { method: "GET", headers });
+    if (!res.ok) return { online: false, endpoint, models: [] };
+    const j = await res.json();
+    const hostSuffix = hostSourceId ? `@@host:${hostSourceId}` : "";
+    const portSuffix = sourcePort ? `@@port:${sourcePort}` : "";
+    const modelSuffix = `${hostSuffix}${portSuffix}`;
+    const portLabel = sourcePort ? `:${sourcePort}` : "";
+    const displaySuffix = hostSourceLabel ? ` (${hostSourceLabel}${portLabel})` : portLabel ? ` (${portLabel})` : "";
+    let rawIds = (j.data ?? []).map((d) => d.id).filter(Boolean);
+    // mlx_lm.server registers both the local path and the HF model ID.
+    // Prefer local absolute paths so each server shows exactly one model entry.
+    const localPaths = rawIds.filter((id) => id.startsWith("/") || id.startsWith("~"));
+    if (localPaths.length > 0) rawIds = localPaths;
+    const models = rawIds.map((id) => ({
+      id: hostSourceId ? `${id}@@${hostSourceId}` : id,
+      name: `${id}${displaySuffix}`,
+      value: `mlx:${id}${modelSuffix}`,
+    }));
+    return { online: true, endpoint, models };
+  } catch {
+    return { online: false, endpoint, models: [] };
+  }
+}
+
+/** True MLX LM check: import mlx_lm in Python (macOS). Not the OpenAI HTTP surface. */
+async function checkMlxLmNativeImport() {
+  const preferred = (process.env.GONEXT_MLX_LM_PYTHON ?? "").trim() || "python3";
+  const code = [
+    "import sys",
+    "try:",
+    "    import mlx_lm",
+    "    v = getattr(mlx_lm, '__version__', None)",
+    "    print(v or 'ok')",
+    "except Exception:",
+    "    sys.exit(1)",
+  ].join("\n");
+
+  const candidates = [preferred];
+  if (preferred === "python3") candidates.push("python");
+
+  const tried = [];
+  for (const exe of [...new Set(candidates)]) {
+    tried.push(exe);
+    try {
+      const { stdout } = await execFile(exe, ["-c", code], {
+        timeout: 15000,
+        maxBuffer: 65536,
+        windowsHide: true,
+      });
+      const version = String(stdout ?? "").trim();
+      return {
+        available: true,
+        python: exe,
+        version: version || undefined,
+        method: "python_import_mlx_lm",
+      };
+    } catch {
+      /* try next */
+    }
+  }
+  return {
+    available: false,
+    python: preferred,
+    method: "python_import_mlx_lm",
+    error: `Could not import mlx_lm (tried: ${tried.join(", ")})`,
+  };
+}
+
+// Probe whether voice transcription is ready (Audio support, task #21):
+// mlx-whisper importable AND the requested model present in the HF hub cache
+// (~/.cache/huggingface/hub, honoring HF_HOME/HF_HUB_CACHE). Returns
+// { available, model, reason } where reason is "ok" | "lib-missing" | "model-missing".
+async function checkWhisperAvailability(model) {
+  const preferred =
+    (process.env.GONEXT_PROBE_PYTHON ?? process.env.GONEXT_MLX_LM_PYTHON ?? "").trim() ||
+    "python3";
+  const repoName = `models--mlx-community--${model}`;
+  const code = [
+    "import os, sys, json, glob",
+    "model = sys.argv[1] if len(sys.argv) > 1 else 'whisper-large-v3-turbo'",
+    "try:",
+    "    import mlx_whisper  # noqa: F401",
+    "except Exception:",
+    "    print(json.dumps({'available': False, 'reason': 'lib-missing'})); sys.exit(0)",
+    "home = os.environ.get('HF_HOME') or os.path.join(os.path.expanduser('~'), '.cache', 'huggingface')",
+    "hub = os.environ.get('HF_HUB_CACHE') or os.path.join(home, 'hub')",
+    `repo = os.path.join(hub, ${JSON.stringify(repoName)})`,
+    "snaps = glob.glob(os.path.join(repo, 'snapshots', '*'))",
+    "ok = False",
+    "for s in snaps:",
+    "    if glob.glob(os.path.join(s, '*.safetensors')) or glob.glob(os.path.join(s, '*.npz')) or os.path.exists(os.path.join(s, 'weights.npz')):",
+    "        ok = True; break",
+    "print(json.dumps({'available': ok, 'reason': 'ok' if ok else 'model-missing', 'cache': hub}))",
+  ].join("\n");
+  const candidates = [preferred];
+  if (preferred === "python3") candidates.push("python");
+  for (const exe of [...new Set(candidates)]) {
+    try {
+      const { stdout } = await execFile(exe, ["-c", code, model], {
+        timeout: 15000,
+        maxBuffer: 65536,
+        windowsHide: true,
+      });
+      const parsed = JSON.parse(String(stdout ?? "").trim() || "{}");
+      return {
+        available: parsed.available === true,
+        model,
+        reason:
+          typeof parsed.reason === "string" ? parsed.reason : "model-missing",
+      };
+    } catch {
+      /* try next candidate */
+    }
+  }
+  return { available: false, model, reason: "lib-missing" };
+}
+
+async function runLocalHealthJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const ollamaPayloadCount = Array.isArray(payload?.ollamaBaseUrls)
+    ? payload.ollamaBaseUrls.length
+    : 0;
+  const mlxUrlCount = Array.isArray(payload?.mlxOpenAiBaseUrls)
+    ? payload.mlxOpenAiBaseUrls.length
+    : payload?.mlxOpenAiBaseUrl ? 1 : 0;
+  console.log(
+    `[gonext-worker] local_health ${jobId} start (ollamaUrls=${ollamaPayloadCount}, mlxUrls=${mlxUrlCount})`
+  );
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running local_health jobId=${jobId}`);
+  try {
+    const ollamaBases = Array.isArray(payload?.ollamaBaseUrls)
+      ? payload.ollamaBaseUrls.map(normalizeBaseUrl).filter(Boolean)
+      : [];
+    const dedup = new Map();
+    let ollamaOnline = false;
+    let ollamaEndpoint = "";
+    const ollamaSources = [];
+    for (const base of ollamaBases) {
+      const baseStart = Date.now();
+      console.log(`[gonext-worker] local_health ${jobId} check ollama ${base}`);
+      const r = await checkOllamaTags(base);
+      console.log(
+        `[gonext-worker] local_health ${jobId} ollama result ${base} online=${r.online} models=${r.models.length} took=${((Date.now() - baseStart) / 1000).toFixed(2)}s`
+      );
+      ollamaOnline = ollamaOnline || r.online;
+      if (!ollamaEndpoint) ollamaEndpoint = r.endpoint;
+       ollamaSources.push({
+        base,
+        label: sourceLabelFromBase(base),
+        endpoint: r.endpoint,
+        online: r.online,
+      });
+      for (const m of r.models) {
+        if (!dedup.has(m.value)) dedup.set(m.value, m);
+      }
+    }
+    const targetWorkerHostId =
+      typeof payload?.targetWorkerHostId === "string"
+        ? payload.targetWorkerHostId.trim()
+        : "";
+    const targetWorkerHostName =
+      typeof payload?.targetWorkerHostName === "string"
+        ? payload.targetWorkerHostName.trim()
+        : "";
+    // MLX servers are discovered dynamically from running mlx_lm.server
+    // processes (macOS), so the dropdown reflects reality with no saved port
+    // list. Only discover when a worker host is targeted so the encoded models
+    // are host-scoped (routable). Each server is probed at 127.0.0.1:<port>/v1.
+    const discoveredMlx = targetWorkerHostId ? await discoverMlxServers() : [];
+    const discoveredByPort = new Map(discoveredMlx.map((s) => [s.port, s]));
+    const mlxRootsDiscovered = discoveredMlx.map(
+      (s) => `http://127.0.0.1:${s.port}/v1`
+    );
+    // Fall back to any explicitly provided base (e.g. a remote host) so
+    // non-local MLX endpoints still work when no local process is found.
+    const mlxRootSingle = normalizeOpenAiV1Root(payload?.mlxOpenAiBaseUrl);
+    const mlxRootsMulti = Array.isArray(payload?.mlxOpenAiBaseUrls)
+      ? payload.mlxOpenAiBaseUrls.map(normalizeOpenAiV1Root).filter(Boolean)
+      : [];
+    const mlxRoots =
+      mlxRootsDiscovered.length > 0
+        ? mlxRootsDiscovered
+        : mlxRootsMulti.length > 0
+          ? mlxRootsMulti
+          : mlxRootSingle
+            ? [mlxRootSingle]
+            : [];
+    const mlxRoot = mlxRoots[0] || null;
+    let mlxNative = null;
+    const modelPathChecksRaw = Array.isArray(payload?.modelPathChecks)
+      ? payload.modelPathChecks
+      : [];
+    const modelPathChecks = [...new Set(modelPathChecksRaw)]
+      .filter((v) => typeof v === "string" && v.trim())
+      .map((v) => String(v).trim())
+      .slice(0, 8);
+    const modelPathStatus = [];
+
+    // Collect results from all MLX endpoints (one per port)
+    const mlxHttpResults = [];
+    for (const root of mlxRoots) {
+      // Extract port from URL for model value encoding
+      let port = null;
+      try {
+        const u = new URL(root.replace(/\/v1\/?$/i, ""));
+        const p = parseInt(u.port, 10);
+        if (p > 0) port = p;
+      } catch { /* ignore */ }
+      const mlxStart = Date.now();
+      console.log(`[gonext-worker] local_health ${jobId} check mlx HTTP ${root} port=${port ?? "default"}`);
+      const result = await checkOpenAiModels(root, payload?.mlxApiKey ?? "", {
+        workerHostId: targetWorkerHostId,
+        hostName: targetWorkerHostName || sourceLabelFromBase(root),
+        port,
+      });
+      console.log(
+        `[gonext-worker] local_health ${jobId} mlx HTTP online=${result.online} models=${result.models.length} took=${((Date.now() - mlxStart) / 1000).toFixed(2)}s`
+      );
+      mlxHttpResults.push(result);
+    }
+    // Merge all per-port results
+    const mlxModelDedup = new Map();
+    let mlxHttpOnline = false;
+    const portsWithModels = new Set();
+    for (const r of mlxHttpResults) {
+      if (r.online) mlxHttpOnline = true;
+      for (const m of r.models) {
+        const pm = String(m.value ?? "").match(/@@port:(\d+)/);
+        if (pm) portsWithModels.add(parseInt(pm[1], 10));
+        if (!mlxModelDedup.has(m.value)) mlxModelDedup.set(m.value, m);
+      }
+    }
+    // A discovered server may be booting (process up, /v1/models not ready).
+    // Synthesize an entry from its `--model` path so it is still visible.
+    for (const { port, modelPath } of discoveredByPort.values()) {
+      if (portsWithModels.has(port) || !modelPath) continue;
+      const hostSuffix = targetWorkerHostId ? `@@host:${targetWorkerHostId}` : "";
+      const value = `mlx:${modelPath}${hostSuffix}@@port:${port}`;
+      if (mlxModelDedup.has(value)) continue;
+      const label = targetWorkerHostName || sourceLabelFromBase(`http://127.0.0.1:${port}`);
+      mlxModelDedup.set(value, {
+        id: targetWorkerHostId ? `${modelPath}@@${targetWorkerHostId}` : modelPath,
+        name: `${modelPath} (${label}:${port}) — starting…`,
+        value,
+      });
+    }
+    const mlxHttp = mlxRoots.length > 0 ? {
+      online: mlxHttpOnline,
+      endpoint: mlxHttpResults[0]?.endpoint,
+      models: [...mlxModelDedup.values()],
+    } : null;
+
+    const wantNativeFallback =
+      (targetWorkerHostId || mlxRoot) &&
+      payload?.mlxNativeFallback !== false &&
+      platform() === "darwin" &&
+      (!mlxHttp?.online || (mlxHttp?.models?.length ?? 0) === 0);
+
+    if (wantNativeFallback) {
+      const t0 = Date.now();
+      console.log(
+        `[gonext-worker] local_health ${jobId} mlx native probe (Python mlx_lm import)`
+      );
+      mlxNative = await checkMlxLmNativeImport();
+      console.log(
+        `[gonext-worker] local_health ${jobId} mlx native available=${mlxNative.available} took=${((Date.now() - t0) / 1000).toFixed(2)}s`
+      );
+    }
+
+    for (const rawPath of modelPathChecks) {
+      const check = await checkModelPathExists(rawPath);
+      modelPathStatus.push(check);
+    }
+
+    const whisperModel =
+      typeof payload?.voiceModel === "string" && payload.voiceModel.trim()
+        ? payload.voiceModel.trim()
+        : "whisper-large-v3-turbo";
+    let whisper = null;
+    if (platform() === "darwin") {
+      const tW = Date.now();
+      whisper = await checkWhisperAvailability(whisperModel);
+      console.log(
+        `[gonext-worker] local_health ${jobId} whisper available=${whisper.available} reason=${whisper.reason} took=${((Date.now() - tW) / 1000).toFixed(2)}s`
+      );
+    }
+
+    let mlx = null;
+    if (mlxRoot || mlxNative?.available) {
+      const httpOk = Boolean(mlxHttp?.online && (mlxHttp?.models?.length ?? 0) > 0);
+      const nativeOk = mlxNative?.available === true;
+      const hostName = targetWorkerHostName || sourceLabelFromBase(mlxRoot || "mlx");
+      const sources = [
+        {
+          workerHostId: targetWorkerHostId || undefined,
+          hostName,
+          endpoint: mlxHttp?.endpoint,
+          online: httpOk || nativeOk,
+          modelCount: httpOk ? mlxHttp.models.length : nativeOk ? 1 : 0,
+        },
+      ];
+      mlx = {
+        configured: httpOk || nativeOk,
+        online: httpOk || nativeOk,
+        models: httpOk
+          ? mlxHttp.models
+          : nativeOk
+            ? [
+                {
+                  id: "mlx_lm_native",
+                  name: mlxNative.version
+                    ? `MLX LM (${mlxNative.version})`
+                    : "MLX LM (Python import OK)",
+                  value: "mlx:mlx_lm_native",
+                },
+              ]
+            : [],
+        endpoint: mlxHttp?.endpoint,
+        http: mlxHttp
+          ? {
+              online: mlxHttp.online,
+              endpoint: mlxHttp.endpoint,
+              modelCount: mlxHttp.models.length,
+            }
+          : undefined,
+        native: mlxNative ?? undefined,
+        sources,
+      };
+    }
+    const result = {
+      ollama:
+        ollamaBases.length > 0
+          ? {
+              configured: dedup.size > 0,
+              online: ollamaOnline,
+              models: [...dedup.values()],
+              endpoint: ollamaEndpoint,
+              sources: ollamaSources,
+            }
+          : undefined,
+      mlx,
+      whisper: whisper ?? undefined,
+      setup:
+        modelPathStatus.length > 0
+          ? {
+              modelPaths: modelPathStatus,
+            }
+          : undefined,
+      // Registered coding workspaces (names/paths only — no secrets) so the web can
+      // show which folders the agent may read/edit on this Mac.
+      workspaces: await readFile(join(homedir(), ".gonext", "workspaces.json"), "utf8")
+        .then((raw) => {
+          const parsed = JSON.parse(raw);
+          return Array.isArray(parsed?.workspaces)
+            ? parsed.workspaces.map((w) => ({
+                name: String(w.name ?? ""),
+                path: String(w.path ?? ""),
+                allowRun: Boolean(w.allowRun),
+              }))
+            : undefined;
+        })
+        .catch(() => undefined),
+    };
+    const totalTimeSeconds = (Date.now() - start) / 1000;
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: JSON.stringify(result),
+        tokenCount: 1,
+        totalTimeSeconds,
+      }),
+    });
+    if (doneRes.status === 404) {
+      console.warn(
+        `[gonext-worker] local_health ${jobId} disappeared before completion PATCH (404 Job not found). Skipping.`
+      );
+      return;
+    }
+    await ensureWorkerOk(doneRes, `complete local_health jobId=${jobId}`);
+    const onlineCount = ollamaSources.filter((s) => s.online).length;
+    console.log(
+      `[gonext-worker] completed local_health ${jobId} (${totalTimeSeconds.toFixed(1)}s) summary: ollamaOnline=${onlineCount}/${ollamaSources.length}, mlx=${mlx ? (mlx.online ? "online" : "offline") : "n/a"}`
+    );
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    if (/failed 404/i.test(message) || /job not found/i.test(message)) {
+      console.warn(
+        `[gonext-worker] local_health ${jobId} no longer exists (404). Skipping fail PATCH.`
+      );
+      return;
+    }
+    const failRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: message,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    if (!failRes.ok) {
+      const snippet = (await failRes.text().catch(() => "")).trim().slice(0, 500);
+      console.error(
+        `[gonext-worker] local_health fail PATCH also failed ${failRes.status} jobId=${jobId}` +
+          (snippet ? ` response=${snippet}` : "")
+      );
+    }
+    console.error(`[gonext-worker] failed local_health ${jobId}:`, message);
+  }
+}
+
+const localHealthInFlight = new Set();
+
+function trackLocalHealthTask(task) {
+  localHealthInFlight.add(task);
+  task.finally(() => {
+    localHealthInFlight.delete(task);
+  });
+}
+
+async function pollOnce() {
+  while (localHealthInFlight.size < localHealthConcurrency) {
+    const res = await workerFetch("/api/worker/jobs/next", { method: "POST" });
+    if (res.status === 204) {
+      return;
+    }
+    if (!res.ok) {
+      const t = await res.text().catch(() => "");
+      throw new Error(`next failed ${res.status}: ${t}`);
+    }
+    const job = await res.json();
+    if (!job?.jobId) {
+      return;
+    }
+    console.log(
+      `[gonext-worker] claimed ${job.jobId} type=${job.jobType ?? "unknown"} modelKey=${job.modelKey ?? "unknown"}`
+    );
+    const isLocalHealthByType = job.jobType === "local_health";
+    const isLocalHealthByModelKey = job.modelKey === "local_health";
+    const isLocalHealthByPayload =
+      Array.isArray(job.payload?.ollamaBaseUrls) ||
+      !!job.payload?.mlxOpenAiBaseUrl ||
+      Array.isArray(job.payload?.mlxOpenAiBaseUrls);
+    if (isLocalHealthByType || isLocalHealthByModelKey || isLocalHealthByPayload) {
+      const task = runLocalHealthJob(job).catch((e) => {
+        console.error("[gonext-worker] local_health task error:", e);
+      });
+      trackLocalHealthTask(task);
+      console.log(
+        `[gonext-worker] local_health in-flight ${localHealthInFlight.size}/${localHealthConcurrency}`
+      );
+      continue;
+    }
+    if (job.jobType === "http_probe") {
+      await runHttpProbeJob(job);
+      return;
+    }
+    if (job.jobType === "list_models") {
+      await runListModelsJob(job);
+      return;
+    }
+    if (job.jobType === "agent_chat") {
+      await runAgentChatJob(job);
+      return;
+    }
+    if (job.jobType === "transcribe") {
+      await runTranscribeJob(job);
+      return;
+    }
+    const isOcrByType = job.jobType === "ocr";
+    const isOcrByPayload =
+      job.payload &&
+      typeof job.payload === "object" &&
+      typeof job.payload.ocrId === "string" &&
+      (typeof job.payload.attachment?.data === "string" ||
+        typeof job.payload.attachment?.s3Object?.getUrl === "string");
+    if (isOcrByType || isOcrByPayload) {
+      await runOcrJob(job);
+      return;
+    }
+    await runChatJob(job);
+    return;
+  }
+}
+
+async function main() {
+  // Task #127, Phase 2: record our own pidfile so `status`/`stop` find us whether we were
+  // launched by `start` (detached), by the REPL's auto-ensure, or run in the foreground.
+  // Best-effort; a failure here must not stop the worker from polling.
+  try {
+    const { PID_FILE } = await import("./daemon-control.mjs");
+    const { unlinkSync } = await import("node:fs");
+    await writeFile(PID_FILE, String(process.pid), "utf8");
+    const cleanup = () => {
+      try {
+        unlinkSync(PID_FILE);
+      } catch {
+        /* already gone */
+      }
+    };
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("exit", cleanup);
+  } catch {
+    /* pidfile is a convenience; polling works without it */
+  }
+  console.log(
+    `[gonext-worker] polling ${apiBase} every ${pollMs}ms (local_health concurrency=${localHealthConcurrency})`
+  );
+  for (;;) {
+    try {
+      await pollOnce();
+    } catch (e) {
+      console.error("[gonext-worker] poll error:", e);
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+}
+
+main();