prism-mcp-server 20.22.2 → 20.22.4

package/README.md

@@ -2,6 +2,11 @@
 
 **Give your AI agent memory that lasts — and see the cloud tokens it never had to spend.** Persistent sessions, knowledge graphs, offline tool-routing, and an auditable savings meter. Fully local and free.
 
+> **Current release: v20.22.4 — oMLX setup and local model roles**
+> Install a pinned oMLX server/model pack from the dashboard or CLI, or connect
+> an existing server. Discover installed models and choose coder/reviewer roles
+> for oMLX and Ollama. Controlled oMLX coding remains text-only.
+
 [![npm](https://img.shields.io/npm/v/prism-mcp-server?color=cb0000&label=npm)](https://www.npmjs.com/package/prism-mcp-server)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-00ADD8)](https://github.com/modelcontextprotocol/servers)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE)
@@ -22,9 +27,10 @@ A paid subscription adds cloud sync, higher model tiers, and team features throu
 
 - **Session memory that survives restarts** — resume projects with handoff notes,
   recent work, open TODOs, and configurable quick, standard, or deep context.
-- **Local-first inference** — bounded work is routed through local Ollama models
-  first, with automatic 2B/4B/9B/27B selection based on installed models,
-  available RAM, context fit, and subscription entitlements.
+- **Local-first inference** — local Ollama models use automatic 2B/4B/9B/27B
+  selection based on installed models, available RAM, context fit, and
+  subscription entitlements. Eligible text-only coding can prefer configured
+  oMLX; explicit task choices override the saved backend preference.
 - **A savings meter you can audit** — `prism savings` (or the `local_savings`
   tool from any host) reports the token volume local serving kept off your
   cloud model: headline, local share, per-model breakdown. It reports tokens,
@@ -59,70 +65,17 @@ A paid subscription adds cloud sync, higher model tiers, and team features throu
   never sent to the cloud), and local/cloud usage is recorded for
   review.
 
-### Explicit on-device oMLX drafts
-
-`prism_infer` keeps Ollama's four-tier routing by default. For an explicitly
-selected text-only code or advisory reviewer draft, pass `local_backend: "omlx"`,
-`mode: "code"`, and optionally `local_model` with the exact advertised model ID.
-This path authenticates `/v1/models` before classification or any Ollama unload;
-an unavailable, unauthenticated, or mismatched model refuses without substitution.
-It reads `OMLX_API_KEY` or the local `~/.omlx/settings.json` key, and model/context
-settings from `~/.omlx/model_settings.json`; `OMLX_MODEL` and a loopback-only
-`OMLX_BASE_URL` can select local configuration. Redirects are refused.
-
-**Requires** an oMLX build with Prism's control routes: the
-[`prism-v0.7.1rc1` branch of dcostenco/omlx](https://github.com/dcostenco/omlx/tree/prism-v0.7.1rc1), upstream oMLX
-0.7.1rc1 plus those routes ([install and settings](https://github.com/dcostenco/omlx/blob/prism-v0.7.1rc1/PRISM.md)). With stock
-oMLX every call is refused. Generation runs as an owned
-job through those routes, so a timeout or cancel is reported only once the
-server confirms the request stopped. An unconfirmed stop refuses later calls
-(`omlx_stop_unproved`, `omlx_provider_busy`).
-
-Before classification, Prism unloads every model Ollama has loaded
-(`keep_alive: 0`; the weights stay on disk and reload on the next Ollama call)
-and waits up to 10 seconds for Ollama to report none. A failed unload, a model
-that does not drain, or one loading meanwhile refuses the call; a newcomer is
-never unloaded. Ollama must be reachable for this step. An OS-owned loopback
-lease on port 19438 excludes other candidate MCP processes; ordinary calls within
-one process share this lease. A busy lease refuses (`omlx_resource_busy`) before
-classification or unloading, and process exit releases it without lock-file
-cleanup. In-process inference and classification wait while an oMLX call owns
-the device. Unknown Ollama state, newly loaded Ollama weights, or available
-memory below a 2 GiB reserve aborts/withholds the generation. Model caches and
-daemons remain in place. Legacy/unmodified MCP processes do not honor the lease;
-their contention is observed and rejected by the watcher.
-
-**Safety screen.** The classifier on this path is the public
-`dcostenco/prism-coder-9b-mlx-8bit`, installed under the name
-`prism-coder-9b-mlx-8bit` in oMLX's model folder (about 9.2 GB while loaded).
-Layer 1's rules only refuse here; the classifier reads everything else, and a
-prompt over 4,000 characters is read whole in 3,600-character windows (the most
-severe verdict stands), never as an excerpt. A classifier failure, an unreadable
-answer, or a missing classifier refuses the call; there is no keyword or Ollama
-fallback. Each classifier read is bounded by 90 seconds and by the call's
-remaining `timeout_ms`, so a classifier that macOS paged out during a long idle
-is waited for rather than refused, and an oversize prompt read in windows
-cannot outlast the call budget; the first unrecoverable read ends the
-classification.
-
-Configured oMLX sampling and reasoning are preserved unless `temperature` or
-`think` is explicit, including through repairs. Generic thinking-disable retries
-are disabled for oMLX, so a model with no thinking budget in oMLX's model
-settings can spend its whole answer reasoning and is refused `think_only`: give
-it a budget there, or pass `think: false`. The default 300-second budget bounds
-oMLX generation, repairs, and history answer checks; `timeout_ms` may override it
-up to 900 seconds. Context sizing uses conservative UTF-8 bytes and the
-configured window.
-
-The same entitlement, reserved-content, history, quality, output-safety, and
-verification policies apply. Explicit oMLX never falls back to Ollama/cloud
-inference. `cloud_fallback: false`, `verify: false`, and `route_guard: "local"`
-keep content-bearing cloud channels disabled for a local draft. Result metadata
-reports `backend: "omlx"`, the selected model, tokens, and `gate_outcome`.
-The MCP envelope carries this public metadata in `structuredContent` alongside
-the existing human header/output text; `next_step` remains available in both.
-Runtime authentication and internal verifier traces are excluded.
-A draft is advisory and requires independent host review; it is not final sign-off.
+### On-device oMLX coding
+
+On Apple Silicon, choose **Settings → Local Coding** in `prism dashboard` to
+install oMLX and its model pack or use an existing server. Auto prefers configured
+oMLX for eligible coding; a saved preference or explicit task choice can select
+Ollama instead. This path requires
+Prism's oMLX integration and its separate classifier; stock oMLX is insufficient.
+See [oMLX setup, tested models, results, and failure handling](docs/omlx.md), or
+start with the [quickstart beside Ollama](#optional-omlx-for-local-coding).
+Explicit oMLX never falls back to Ollama or cloud inference; drafts still need
+host review and tests.
 
 ## Get started
 
@@ -235,6 +188,41 @@ or by re-enabling after each run.
 <details>
 <summary>Release history (optional)</summary>
 
+## What's New in v20.22.4
+
+- **Dashboard and CLI setup:** Settings → Local Coding and `prism local` install
+  a pinned oMLX server/model pack with progress, retry and managed startup, or
+  connect an existing server. See the [oMLX guide](docs/omlx.md) for requirements.
+- **Saved coding preference:** choose Auto, oMLX or Ollama without restarting
+  Prism. Auto prefers configured oMLX for eligible text-only coding; an explicit
+  per-task backend overrides that preference.
+- **Discovered model roles:** select installed coder and reviewer models for
+  each backend, including the same model for both roles. Explicit task model
+  choices win. Reported sizes and conservative memory estimates help compare
+  choices; unknown metadata stays unknown and estimates do not guarantee fit.
+- **Managed isolation:** model discovery, Hub cache and cluster launchers stay
+  private to the managed installation. Competing Ollama residency refuses the
+  call without unloading other jobs.
+- **Setup-state hardening:** bounded reads use one file handle and reject
+  symlinks, closing the filesystem race reported by CodeQL.
+- **Vision boundary:** this release does not enable image requests through the
+  controlled oMLX coding path. Picture-recognition tests remain separate work.
+
+## What's New in v20.22.3
+
+- **Dependency fixes:** Hono 4.13.11 addresses its static-path middleware
+  bypass advisory; Vite 8.2.4 addresses its development editor-launch advisories.
+- **Local resource probes use numeric loopback by default.** The default
+  Ollama endpoint is now `http://127.0.0.1:11434`, so a stalled `localhost`
+  DNS lookup cannot block those probes. Explicit URL overrides are preserved;
+  IPv6-only servers need an explicit URL.
+- **Read-only oMLX inspection accepts release-candidate versions.** Valid
+  `rcN` labels no longer invalidate status. Inspection still reports
+  generation disabled and the provider not qualified; it is not an activation
+  or a generation check.
+- **Stable oMLX setup:** the current setup link uses the Prism integration
+  based on upstream `v0.7.1`. Stock oMLX still lacks the required control routes.
+
 ## What's New in v20.22.2
 
 **Why it matters:** an agent that followed `session_task_route`'s advice was
@@ -1333,6 +1321,32 @@ requests are refused rather than answered blind when no tier (or the Layer 1
 safety classifier) can actually see the image, so a text-only model is never
 handed a prompt about a screenshot it never received. The 27b is text only.
 
+### Optional oMLX for local coding
+
+Use **Settings → Local Coding** in `prism dashboard` for opt-in installation,
+progress, retry, connection checks, and backend/model selection. Or use
+`prism local install` followed by `prism local start`. npm installation never
+downloads models automatically. The managed pack requires Apple Silicon,
+macOS 15+, Python 3.11–3.13, 32 GiB memory and 40 GiB free disk; it keeps existing
+servers and jobs running. Auto prefers configured oMLX for eligible coding;
+explicit smaller model ceilings stay on Ollama, and task overrides take priority.
+
+For manual setup, install the **Prism integration** of oMLX, its required
+9B classifier, and a drafting model such as Qwen3.8-27B oQ4e. Set a loopback API
+key, enable chunked prefill, disable MTP/DFlash/speculative prefill, and configure
+model context/thinking budgets. Then verify a call with `local_backend: "omlx"`,
+`mode: "code"`, and the exact advertised `local_model`. Ollama need not be
+running; Prism refuses device contention without unloading another job's models.
+
+Follow the [step-by-step oMLX guide](docs/omlx.md) for pinned install/download
+commands, server startup, a first MCP call, and troubleshooting. Its
+[tested model table](docs/omlx.md#tested-models-and-trade-offs) separates native
+oMLX checkpoints from the experimental Strata GGUF runtime. The
+[coding and review results](docs/omlx.md#observed-coding-and-review-results)
+show measured trade-offs and limits; they do not establish an overall winner.
+Stock oMLX cannot serve this Prism path, and explicit oMLX has no inference
+fallback. Local reviews remain advisory.
+
 ---
 
 ## What it does
@@ -1483,6 +1497,9 @@ and `verify` govern the other two channels.
 
 ## Models
 
+This section describes the default **Ollama fleet**. For explicit oMLX coding,
+see [tested oMLX models and trade-offs](docs/omlx.md#tested-models-and-trade-offs).
+
 The `prism-coder` fleet uses Qwen3.5 for MCP tool-routing AND general inference. The 9B and 27B are fine-tuned; the 2B and 4B use stock Qwen3.5-4B at different quantization levels. The 27B scored 100% on our internal 115-case tool-routing suite and 100% on an internal 15-problem coding eval, at $0 inference cost. These are self-run evaluations, not [BFCL](https://gorilla.cs.berkeley.edu/leaderboard.html) leaderboard submissions.
 
 `prism_infer` supports three modes: `route` (tool routing, fast), `chat` (conversation) and `code` (code generation). Reasoning is decided by the **tier**, not the mode: a tier carrying `MODEL_TIERS.prefersThinking` also carries a `minLocalTokens` floor so reasoning cannot crowd out the answer, and only those tiers use `<think>` blocks (stripped before the response is served). The 9B does; the 4B and 2B do not, because on those tiers reasoning drew down the same `num_predict` budget the answer needed and returned an empty response. An explicit `think: true` still overrides, for a caller who has sized `max_tokens` for it. If the local model fails a quality gate (empty, think-only, or truncated), paid tiers automatically escalate to Gemini 3.6 Flash via the Synalux portal.
@@ -1553,7 +1570,7 @@ selection.
 
 | Layer | What | Model | Cost |
 |---|---|---|---|
-| **L1** | Crisis/medical safety gate | None (regex) | 0 ms |
+| **L1** | Crisis/medical safety rules and local classification | Backend-specific classifier (required 9B on oMLX) | Varies |
 | **L3-Registry** | Envelope validation + advertised-tool enforcement (all tiers) | None | 0 ms |
 | **L3-Route** | Authenticated deterministic route correction (Standard+) | None | Network latency |
 | **L3-Tier0** | Integer grounding (set membership) | None (deterministic) | 0 ms |
@@ -1598,10 +1615,14 @@ check, the local 9B passed 2/3 tasks; the local 27B and Gemini 3.6 Flash each
 passed 3/3. This is a self-published regression signal, not an independent
 leaderboard or a claim of broad model equivalence.
 
+For the separate October 2026 coding and advisory-review comparison, see
+[oMLX and Strata results and limitations](docs/omlx.md#observed-coding-and-review-results).
+
 ### Cloud Escalation (`cloud_fallback`)
 
-Prism always tries an eligible local model first. If the quality gate detects
-an empty, truncated, think-only, or looping response, or the safety screen
+For the default **Ollama backend**, Prism tries an eligible local model first.
+If the quality gate detects an empty, truncated, think-only, or looping
+response, or the safety screen
 finds the request uncertain or reserved, a paid plan escalates the request
 through Gemini 3.6 Flash. Free-tier routing stays local and reports the
 outcome without making a cloud call.
@@ -1612,6 +1633,9 @@ for a call, which the clinical delegation rules do for drafting; pass `true`
 to ask for it, which still requires a plan with cloud. A request that carries
 an image is never escalated; screenshots stay on this device.
 
+Explicit `local_backend: "omlx"` never falls back to cloud inference or Ollama,
+regardless of plan or `cloud_fallback`. See [oMLX behavior](docs/omlx.md#runtime-behavior-and-failure-handling).
+
 ---
 
 ## Why Prism Coder

package/dist/cli.js

@@ -17,6 +17,48 @@ import { isRecoverableStartupStorageError } from './utils/startupRecovery.js';
 import { verifyBehaviorHandler } from './tools/behavioralVerifierHandler.js';
 import { dashboardOpenSuccessMessage, findRunningDashboardAccessState, openDashboardUrl, } from './dashboard/dashboardAccess.js';
 const program = new Command();
+const local = program.command('local').description('Local coding setup and backend preference');
+local.command('status').description('Show oMLX installation and saved coding preference').action(async () => {
+    const { omlxSetup } = await import('./utils/omlxSetup.js');
+    const { readLocalCodingSettings } = await import('./utils/localCodingSettings.js');
+    console.log(JSON.stringify({ settings: await readLocalCodingSettings(), managed: await omlxSetup.status() }, null, 2));
+});
+local.command('install').description('Opt in to isolated oMLX + pinned classifier/coder downloads (about 25 GB; 40 GiB free required)').action(async () => {
+    const { omlxSetup } = await import('./utils/omlxSetup.js');
+    try {
+        const job = await omlxSetup.install();
+        console.log(`oMLX setup ${job.id} started. Follow progress in Dashboard → Account & Settings → Local Coding.`);
+        await omlxSetup.waitForInstall();
+        const state = await omlxSetup.status();
+        if (state.job?.state !== 'complete')
+            throw new Error(state.job?.error ?? 'oMLX setup did not complete.');
+        console.log('Installed. Run prism local start, then select Prism-managed installation in the Local Coding dashboard.');
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : 'oMLX setup failed.');
+        process.exitCode = 1;
+    }
+});
+local.command('start').description('Start the installed managed oMLX server without replacing an existing daemon').action(async () => {
+    const { omlxSetup } = await import('./utils/omlxSetup.js');
+    try {
+        console.log(JSON.stringify(await omlxSetup.start()));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : 'Unable to start oMLX.');
+        process.exitCode = 1;
+    }
+});
+local.command('backend <backend>').description('Save auto, omlx or ollama for coding; explicit tasks override it').action(async (backend) => {
+    const { readLocalCodingSettings, saveLocalCodingSettings, isLocalCodingBackend } = await import('./utils/localCodingSettings.js');
+    if (!isLocalCodingBackend(backend)) {
+        console.error('Backend must be auto, omlx or ollama.');
+        process.exitCode = 1;
+        return;
+    }
+    await saveLocalCodingSettings({ ...await readLocalCodingSettings(), backend });
+    console.log(`Saved coding preference: ${backend}. Applies to new tasks; explicit task choices override it.`);
+});
 /** Build the stable `prism load --json` envelope from depth-specific context. */
 export function buildLoadJsonOutput(project, data, level, metadata) {
     const filteredData = filterPrismMemoryContext(data);

package/dist/config.js

@@ -345,15 +345,16 @@ export const PRISM_TURBOQUANT_TIEBREAKER_EPSILON = Number.isFinite(rawTiebreaker
 //
 // Set PRISM_LOCAL_LLM_ENABLED=true to activate.
 // Set PRISM_LOCAL_LLM_MODEL to override the model tag.
-// Set PRISM_LOCAL_LLM_URL to override the Ollama endpoint (default: localhost:11434).
+// Set PRISM_LOCAL_LLM_URL to override the Ollama endpoint (default: 127.0.0.1:11434).
 // Set PRISM_LOCAL_LLM_TIMEOUT_MS to override per-call timeout (default: 60000, max: 300000).
 // Set PRISM_STRICT_LOCAL_MODE=true to block cloud fallback when local LLM is enabled (HIPAA).
 /** Master switch — enables the local prism-coder LLM for background tasks. */
 export const PRISM_LOCAL_LLM_ENABLED = process.env.PRISM_LOCAL_LLM_ENABLED === "true"; // Opt-in, default false
 /** Ollama model tag to use for local LLM calls. */
 export const PRISM_LOCAL_LLM_MODEL = (process.env.PRISM_LOCAL_LLM_MODEL || "prism-coder:9b").trim();
-/** Ollama base URL. Override for remote Ollama instances. */
-export const PRISM_LOCAL_LLM_URL = (process.env.PRISM_LOCAL_LLM_URL || "http://localhost:11434").trim();
+/** Numeric loopback avoids queuing local health probes behind getaddrinfo work.
+ * Explicit overrides still support custom hostnames and IPv6-only listeners. */
+export const PRISM_LOCAL_LLM_URL = (process.env.PRISM_LOCAL_LLM_URL || "http://127.0.0.1:11434").trim();
 /** Per-call timeout in ms. Prevents stalled background tasks. Capped at 300s. */
 export const PRISM_LOCAL_LLM_TIMEOUT_MS = (() => {
     const raw = parseInt(process.env.PRISM_LOCAL_LLM_TIMEOUT_MS || "60000", 10);

package/dist/dashboard/localCodingRouter.js

@@ -0,0 +1,120 @@
+import { configuredOmlxModel, detectOmlx, hasOmlxControl, inspectOmlx, inspectOmlxCodingModels, OmlxError } from "../utils/omlxProvider.js";
+import { localCodingPreference } from "../utils/localCodingPreference.js";
+import { readLocalCodingSettings, saveLocalCodingSettings, resolveLocalCodingModel } from "../utils/localCodingSettings.js";
+import { omlxSetup, OmlxSetupError, OMLX_SETUP_MODELS } from "../utils/omlxSetup.js";
+import { inspectOllamaCodingModels } from "../utils/ollamaCodingModels.js";
+import { getAvailableMemoryBytes } from "../utils/availableMemory.js";
+const MAX_BODY_BYTES = 4096;
+const defaults = { setup: omlxSetup, settings: readLocalCodingSettings, save: saveLocalCodingSettings,
+    preference: localCodingPreference, inspect: inspectOmlx, detect: detectOmlx, control: hasOmlxControl, configuredModel: configuredOmlxModel,
+    omlxModels: inspectOmlxCodingModels, ollamaModels: inspectOllamaCodingModels, availableMemory: getAvailableMemoryBytes };
+function json(res, status, value) {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "private, no-store" });
+    res.end(JSON.stringify(value));
+}
+function loopback(req) {
+    return ["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(req.socket.remoteAddress ?? "");
+}
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const data of req) {
+        const chunk = Buffer.from(data);
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES)
+            throw new Error("invalid_body");
+        chunks.push(chunk);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+}
+/** Mounted only after the dashboard's Host, token and authentication gates. */
+export async function handleLocalCodingRoutes(url, req, res, overrides = {}) {
+    if (url.pathname !== "/api/local-coding" && !url.pathname.startsWith("/api/local-coding/"))
+        return false;
+    const deps = { ...defaults, ...overrides };
+    try {
+        if (req.method === "GET" && url.pathname === "/api/local-coding") {
+            const settings = await deps.settings();
+            let preference, preferenceError;
+            try {
+                preference = await deps.preference();
+            }
+            catch {
+                preferenceError = "Backend preference inspection failed. You can change the saved settings below; check PRISM_LOCAL_CODING_BACKEND if an environment override is set.";
+                // Recovery controls remain available. Inference still refuses a
+                // broken configuration rather than silently changing backend.
+                preference = { saved: settings.backend, effective: settings.backend, envOverride: null, configured: false };
+            }
+            const managed = await deps.setup.status();
+            const inventories = await Promise.allSettled([deps.omlxModels(), deps.ollamaModels()]);
+            const discovered = { omlx: inventories[0].status === "fulfilled" ? inventories[0].value : [],
+                ollama: inventories[1].status === "fulfilled" ? inventories[1].value : [] };
+            const discoveryErrors = { omlx: inventories[0].status === "rejected" ? "oMLX model metadata unavailable; memory requirements unknown." : null,
+                ollama: inventories[1].status === "rejected" ? "Ollama model inventory unavailable. Check the configured server." : null };
+            let connection = { connected: false, control: false, models: [] };
+            try {
+                const observation = await deps.inspect();
+                connection = { connected: true, control: false, models: observation.advertised_models, adminUrl: new URL(observation.url).origin + "/admin" };
+                const model = resolveLocalCodingModel(settings, "omlx", "coder") ?? await deps.configuredModel();
+                if (model) {
+                    const target = await deps.detect(model);
+                    connection.model = model;
+                    connection.control = await deps.control(target);
+                }
+                else
+                    connection.error = "Choose an advertised coding model and save the preference.";
+            }
+            catch (error) {
+                connection.error = error instanceof OmlxError ? error.reason : "Connection check unavailable.";
+            }
+            json(res, 200, { settings, preference, preferenceError, managed, connection, discovered, discoveryErrors,
+                availableMemoryBytes: deps.availableMemory(), canManage: loopback(req),
+                requiredClassifier: OMLX_SETUP_MODELS[0].id });
+            return true;
+        }
+        if (req.method !== "POST") {
+            json(res, 405, { error: "Method not allowed" });
+            return true;
+        }
+        // Installing packages is a local operator action. A configured remote
+        // dashboard origin and cross-port browser requests do not authorize it.
+        const origin = req.headers.origin;
+        let sameOrigin = !origin;
+        try {
+            if (origin)
+                sameOrigin = new URL(origin).host === req.headers.host;
+        }
+        catch {
+            sameOrigin = false;
+        }
+        if (!loopback(req) || !sameOrigin || !req.headers["content-type"]?.startsWith("application/json")) {
+            json(res, 403, { error: "Open this dashboard on this Mac to change local coding setup." });
+            return true;
+        }
+        const body = await readBody(req);
+        if (url.pathname === "/api/local-coding/preferences") {
+            await deps.save(body);
+            json(res, 200, { saved: true });
+            return true;
+        }
+        if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length) {
+            json(res, 400, { error: "This action accepts no custom setup arguments." });
+            return true;
+        }
+        if (url.pathname === "/api/local-coding/install") {
+            json(res, 202, await deps.setup.install());
+            return true;
+        }
+        if (url.pathname === "/api/local-coding/start") {
+            json(res, 202, await deps.setup.start());
+            return true;
+        }
+        json(res, 404, { error: "Unknown local coding action" });
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof OmlxSetupError ? error.message : "Local coding setup unavailable. Check the saved settings or local setup log and retry.";
+        json(res, 400, { error: message });
+        return true;
+    }
+}

package/dist/dashboard/localCodingUI.js

@@ -0,0 +1,171 @@
+import { OMLX_SETUP_MODELS } from "../utils/omlxSetup.js";
+export function localCodingPanelHTML() {
+    return `<div class="s-tab-panel" id="spanel-local">
+      <div class="setting-section">Local coding</div>
+      <p class="setting-desc">Choose where coding drafts and local reviews run. Models are discovered from your servers. The same model can serve both roles. Explicit task choices override these preferences. Tool routing and images keep their supported backend.</p>
+      <form id="local-coding-form" onsubmit="saveLocalCoding(event)" style="display:grid;gap:14px;margin-top:18px">
+        <label class="setting-label" for="local-coding-backend">Preferred coding backend</label>
+        <select class="setting-select" id="local-coding-backend" style="width:100%;max-width:100%" disabled>
+          <option value="auto">Auto — prefer configured oMLX</option><option value="omlx">oMLX</option><option value="ollama">Ollama</option>
+        </select>
+        <label class="setting-label" for="local-coding-source">oMLX connection</label>
+        <select class="setting-select" id="local-coding-source" style="width:100%;max-width:100%" disabled>
+          <option value="existing">Existing oMLX server</option><option value="managed">Prism-managed installation</option>
+        </select>
+        ${["omlx", "ollama"].map(backend => `<fieldset style="min-width:0;border:1px solid var(--border-glass);border-radius:8px;padding:12px;display:grid;gap:10px"><legend class="setting-label">${backend === "omlx" ? "oMLX" : "Ollama"} models</legend>
+          ${["coder", "reviewer"].map(role => `<label class="setting-label" for="local-coding-${backend}-${role}">${role === "coder" ? "Coder" : "Reviewer"}</label><select class="setting-select" id="local-coding-${backend}-${role}" style="width:100%;max-width:100%" onchange="renderLocalCodingMemory()" disabled></select><p class="setting-desc" id="local-coding-${backend}-${role}-memory" style="margin:0;overflow-wrap:anywhere"></p>`).join("")}
+          <p class="setting-desc" id="local-coding-${backend}-discovery" style="margin:0;overflow-wrap:anywhere" role="status"></p>
+        </fieldset>`).join("")}
+        <p class="setting-desc" id="local-coding-memory" style="margin:0"></p>
+        <div class="skill-actions" style="flex-wrap:wrap"><button class="skill-save-btn" id="local-coding-save" type="submit" disabled>Save coding preference</button><button class="skill-upload-btn" type="button" onclick="loadLocalCoding(false)">Check saved connection</button></div>
+      </form>
+      <p id="local-coding-saved" class="setting-desc" aria-live="polite"></p>
+      <div id="local-coding-connection" class="setting-desc" role="status" style="margin:16px 0;padding:12px;border:1px solid var(--border-glass);border-radius:8px">Checking local coding setup…</div>
+      <a id="local-coding-admin" target="_blank" rel="noopener noreferrer" style="display:none">Open oMLX settings</a>
+      <div class="setting-section" style="margin-top:24px">Set up oMLX on this Mac</div>
+      <p class="setting-desc">Use your existing server to avoid duplicate downloads. New setup installs the pinned Prism-compatible server in an isolated Python environment. Downloads are opt-in; npm installation never starts them.</p>
+      <p class="setting-desc">Apple Silicon · macOS 15+ · Python 3.11–3.13 · 32 GiB unified memory · 40 GiB free disk. The standard install uses generic kernels; full Xcode builds can be faster.</p>
+      <ul class="setting-desc" style="line-height:1.8;padding-left:20px">${OMLX_SETUP_MODELS.map(model => `<li><a href="https://huggingface.co/${model.repo}" target="_blank" rel="noopener noreferrer">${model.label}</a> — about ${model.approximateGB} GB</li>`).join("")}</ul>
+      <p class="setting-desc">This optional starter pack does not restrict your model choices above. Review the model licenses before downloading. Managed setup uses port 8001, keeps a 10 GB cache limit, and leaves existing oMLX and Ollama processes running. Prism's oMLX path requires a 27B model ceiling from the task and plan, plus available memory.</p>
+      <div id="local-coding-setup-state" role="status" class="setting-desc" style="margin:14px 0"></div>
+      <progress id="local-coding-progress" aria-label="oMLX setup progress" style="display:none;width:100%"></progress>
+      <div class="skill-actions" style="flex-wrap:wrap"><button class="skill-save-btn" type="button" id="local-coding-install" onclick="localCodingAction('install')" disabled>Install oMLX + recommended models</button><button class="skill-upload-btn" type="button" id="local-coding-start" onclick="localCodingAction('start')" disabled>Start managed oMLX</button></div>
+      <p class="setting-desc" style="margin-top:12px">After starting, select <strong>Prism-managed installation</strong> above and save. Managed connection settings stay separate from your existing server. Drafts require host review and tests.</p>
+      <p id="local-coding-error" role="alert" style="color:var(--accent-red);overflow-wrap:anywhere"></p>
+    </div>`;
+}
+/** ES5 to match the dashboard's inline-script compatibility contract. */
+export function localCodingScript() {
+    return `
+var localCodingLoaded = false;
+var localCodingBusy = false;
+var localCodingPoll;
+var localCodingReadSequence = 0;
+var localCodingStartingUntil = 0;
+var localCodingActionError = '';
+var localCodingModels = {omlx:[],ollama:[]};
+var localCodingDiscoveryErrors = {};
+function localCodingGiB(bytes) { return (bytes / Math.pow(1024, 3)).toFixed(1) + ' GiB'; }
+function renderLocalCodingMemory() {
+    ['omlx','ollama'].forEach(function(backend) {
+        ['coder','reviewer'].forEach(function(role) {
+            var id = document.getElementById('local-coding-' + backend + '-' + role).value;
+            var model = localCodingModels[backend].filter(function(item) { return item.id === id; })[0];
+            var text = !id ? 'Uses the backend default. No role-specific model is saved.' : !model ? (localCodingDiscoveryErrors[backend] ? 'Inventory unavailable; model availability and memory are unknown.' : 'Saved model is unavailable. It will be refused rather than replaced.') :
+                (model.weightBytes ? 'Reported weights: ' + localCodingGiB(model.weightBytes) : 'Weight size unknown') +
+                (model.loadedBytes ? ' · Loaded memory: ' + localCodingGiB(model.loadedBytes) : model.loaded === true ? ' · Loaded; memory unknown' : model.loaded === false ? ' · Not loaded' : ' · Load status unknown') +
+                (model.weightBytes ? ' · Cold-load RAM estimate: at least ' + localCodingGiB(Math.max(model.weightBytes * 1.5, model.weightBytes + 2 * Math.pow(1024,3))) : ' · RAM requirements unknown');
+            document.getElementById('local-coding-' + backend + '-' + role + '-memory').textContent = text;
+        });
+    });
+}
+function localCodingRequest(path, body) {
+    return fetch('/api/local-coding' + path, body === undefined ? {cache:'no-store'} : {
+        method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)
+    }).then(function(response) { return response.json().then(function(data) {
+        if (!response.ok || data.error) throw new Error(data.error || 'Local coding request failed.');
+        return data;
+    }); });
+}
+function loadLocalCoding(reset) {
+    clearTimeout(localCodingPoll);
+    var sequence = ++localCodingReadSequence;
+    return localCodingRequest('').then(function(data) {
+        if (sequence !== localCodingReadSequence) return data;
+        var settings = data.settings;
+        if (reset || !localCodingLoaded) {
+            document.getElementById('local-coding-backend').value = settings.backend;
+            document.getElementById('local-coding-source').value = settings.source;
+        }
+        ['backend','source','save'].forEach(function(name) { document.getElementById('local-coding-' + name).disabled = !data.canManage || localCodingBusy; });
+        document.getElementById('local-coding-backend').disabled = data.preference.envOverride !== null || !data.canManage || localCodingBusy;
+        var override = data.preference.envOverride;
+        document.getElementById('local-coding-saved').textContent = 'Saved: ' + settings.backend + ' · ' + settings.source + (override ? ' · Environment override: ' + override : ' · Applies to new tasks without restarting');
+        var connection = data.connection;
+        var classifier = connection.models.indexOf(data.requiredClassifier) >= 0;
+        document.getElementById('local-coding-connection').textContent = !connection.connected ? 'oMLX not connected. Start or configure the selected server.' :
+            'oMLX connected · ' + (connection.model || 'choose a coding model') + ' · ' + (connection.control ? 'Prism control available' : 'Prism control unavailable') + ' · ' + (classifier ? 'classifier advertised' : 'required classifier not advertised');
+        if (connection.error) document.getElementById('local-coding-connection').textContent += ' · ' + connection.error;
+        localCodingModels = data.discovered || {omlx:[],ollama:[]};
+        localCodingDiscoveryErrors = data.discoveryErrors || {};
+        // Older compatible servers may advertise IDs without memory metadata.
+        if (!localCodingModels.omlx.length && connection.connected) localCodingModels.omlx = connection.models.map(function(id) { return {id:id}; });
+        ['omlx','ollama'].forEach(function(backend) {
+            ['coder','reviewer'].forEach(function(role) {
+                var select = document.getElementById('local-coding-' + backend + '-' + role);
+                var saved = settings.models && settings.models[backend] && settings.models[backend][role];
+                if (!saved && backend === 'omlx' && role === 'coder') saved = settings.model;
+                var value = reset || !localCodingLoaded ? saved || '' : select.value;
+                select.textContent = '';
+                var automatic = document.createElement('option'); automatic.value = ''; automatic.textContent = 'Use backend default'; select.appendChild(automatic);
+                localCodingModels[backend].forEach(function(model) { var option = document.createElement('option'); option.value = model.id; option.textContent = model.id; select.appendChild(option); });
+                if (value && !localCodingModels[backend].some(function(model) { return model.id === value; })) {
+                    var unavailable = document.createElement('option'); unavailable.value = value; unavailable.textContent = (localCodingDiscoveryErrors[backend] ? 'Availability unknown: ' : 'Unavailable: ') + value; select.appendChild(unavailable);
+                }
+                select.value = value;
+                select.disabled = !data.canManage || localCodingBusy;
+            });
+            document.getElementById('local-coding-' + backend + '-discovery').textContent = data.discoveryErrors && data.discoveryErrors[backend] || localCodingModels[backend].length + ' models detected. Refresh checks inventory without loading models.';
+        });
+        localCodingLoaded = true;
+        document.getElementById('local-coding-memory').textContent = 'Available RAM: ' + (data.availableMemoryBytes ? localCodingGiB(data.availableMemoryBytes) : 'unknown') + '. RAM estimates exclude workload-dependent peaks and do not guarantee a fit. Runtime admission checks still apply.';
+        renderLocalCodingMemory();
+        var admin = document.getElementById('local-coding-admin');
+        admin.style.display = connection.adminUrl ? 'inline' : 'none';
+        if (connection.adminUrl) admin.href = connection.adminUrl;
+        var state = data.managed, job = state.job, running = job && job.state === 'running';
+        document.getElementById('local-coding-setup-state').textContent = (state.installed ? 'Server installed' : 'Server not installed') + ' · ' + state.models.filter(function(model) { return model.downloaded; }).length + '/' + state.models.length + ' models downloaded · ' + state.freeDiskGB + ' GiB free' + (job ? ' · ' + job.stage + ' (' + job.state + ')' : '') + (state.server.connected ? ' · Managed server connected' : '');
+        document.getElementById('local-coding-progress').style.display = running ? 'block' : 'none';
+        var install = document.getElementById('local-coding-install');
+        install.disabled = !data.canManage || !state.supported || running || localCodingBusy;
+        install.textContent = job && (job.state === 'failed' || job.state === 'interrupted') ? 'Retry / resume setup' : state.installed && state.models.every(function(model) { return model.downloaded; }) ? 'Verify installed setup' : 'Install oMLX + recommended models';
+        document.getElementById('local-coding-start').disabled = !data.canManage || !state.installed || state.models.some(function(model) { return !model.downloaded; }) || running || localCodingBusy || state.server.connected;
+        if (!state.supported) document.getElementById('local-coding-setup-state').textContent += ' · Installation requires Apple Silicon with macOS 15+';
+        if (!data.canManage) document.getElementById('local-coding-error').textContent = 'Open the dashboard on this Mac to manage local setup.';
+        else document.getElementById('local-coding-error').textContent = localCodingActionError || data.preferenceError || (job && job.error) || '';
+        if (state.server.connected) localCodingStartingUntil = 0;
+        if (running || localCodingBusy || Date.now() < localCodingStartingUntil) localCodingPoll = setTimeout(function() { loadLocalCoding(false); }, 4000);
+        return data;
+    }).catch(function(error) {
+        if (sequence !== localCodingReadSequence) return;
+        document.getElementById('local-coding-error').textContent = error.message;
+        ['save','install','start'].forEach(function(name) { document.getElementById('local-coding-' + name).disabled = true; });
+    });
+}
+function saveLocalCoding(event) {
+    event.preventDefault();
+    var settings = {backend:document.getElementById('local-coding-backend').value,source:document.getElementById('local-coding-source').value};
+    settings.models = {};
+    ['omlx','ollama'].forEach(function(backend) {
+        settings.models[backend] = {};
+        ['coder','reviewer'].forEach(function(role) {
+            var model = document.getElementById('local-coding-' + backend + '-' + role).value;
+            if (model) settings.models[backend][role] = model;
+        });
+    });
+    localCodingBusy = true;
+    localCodingActionError = '';
+    localCodingReadSequence++;
+    document.getElementById('local-coding-error').textContent = '';
+    document.getElementById('local-coding-save').disabled = true;
+    return localCodingRequest('/preferences', settings).then(function() {
+        localCodingBusy = false;
+        return loadLocalCoding(true);
+    }).catch(function(error) { localCodingBusy = false; document.getElementById('local-coding-error').textContent = error.message; document.getElementById('local-coding-save').disabled = false; });
+}
+function localCodingAction(action) {
+    localCodingBusy = true;
+    localCodingActionError = '';
+    localCodingReadSequence++;
+    document.getElementById('local-coding-error').textContent = '';
+    document.getElementById('local-coding-setup-state').textContent = action === 'start' ? 'Starting managed oMLX. Waiting for the server connection…' : 'Checking prerequisites before setup…';
+    document.getElementById('local-coding-progress').style.display = 'block';
+    ['install','start'].forEach(function(name) { document.getElementById('local-coding-' + name).disabled = true; });
+    return localCodingRequest('/' + action, {}).then(function() {
+        localCodingBusy = false;
+        if (action === 'start') localCodingStartingUntil = Date.now() + 90000;
+        return loadLocalCoding(false);
+    }).catch(function(error) { localCodingBusy = false; localCodingActionError = error.message; document.getElementById('local-coding-error').textContent = error.message; loadLocalCoding(false); });
+}
+`;
+}

package/dist/dashboard/server.js

@@ -36,6 +36,7 @@ import { buildVaultDirectory } from "../utils/vaultExporter.js";
 import { redactSettings } from "../tools/commonHelpers.js";
 import { handleGraphRoutes } from "./graphRouter.js";
 import { handleAccountRoutes } from "./accountRouter.js";
+import { handleLocalCodingRoutes } from "./localCodingRouter.js";
 import { createDashboardStorageAccessor } from "./storageAccessor.js";
 import { DASHBOARD_READ_MESSAGES } from "./readMessages.js";
 import { isDashboardSettingKeyAllowed, isDashboardSettingValueAllowed } from "./settingsPolicy.js";
@@ -697,6 +698,8 @@ return false;}
                 return res.end(JSON.stringify({ ok: true, role, namespace: "user_skill" }));
             }
             // ─── API: Synalux Account & Subscription ───
+            if (await handleLocalCodingRoutes(url, req, res))
+                return;
             if (url.pathname.startsWith("/api/account")) {
                 if (await handleAccountRoutes(url, req, res))
                     return;