prism-mcp-server 20.22.2 → 20.22.4

package/dist/dashboard/ui.js

@@ -16,6 +16,7 @@
 import { ANALYTICS_DATE_PATTERN, ANALYTICS_METRIC_IDS, DASHBOARD_READ_MESSAGES } from './readMessages.js';
 import { DARK_FACTORY_SETTINGS_UNAVAILABLE } from '../darkfactory/enablement.js';
 import { ACTR_SETTINGS_UNAVAILABLE, ACTR_UI } from '../utils/actrEnablement.js';
+import { localCodingPanelHTML, localCodingScript } from './localCodingUI.js';
 export function renderDashboardLocalOpenHTML() {
     return `<!DOCTYPE html>
 <html lang="en">
@@ -481,6 +482,10 @@ export function renderDashboardHTML(version) {
     .skill-save-btn { background: var(--accent-purple); color: #fff; border: none; border-radius: var(--radius-sm);
       padding: 0.45rem 1rem; font-size: 0.82rem; font-weight: 600; cursor: pointer; transition: opacity 0.2s; }
     .skill-save-btn:hover { opacity: 0.85; }
+    #spanel-local .setting-desc { font-size: 0.8rem; line-height: 1.55; }
+    #spanel-local a { color: var(--accent-purple); text-underline-offset: 3px; }
+    #spanel-local button, #spanel-local select, #spanel-local input { min-height: 40px; }
+    #spanel-local button:disabled { opacity: 0.5; cursor: default; }
     .skill-upload-btn { background: none; border: 1px solid var(--border-glass); color: var(--text-secondary);
       border-radius: var(--radius-sm); padding: 0.45rem 0.85rem; font-size: 0.82rem; cursor: pointer; transition: all 0.2s; }
     .skill-upload-btn:hover { border-color: var(--accent-purple); color: var(--accent-purple); }
@@ -1239,6 +1244,7 @@ export function renderDashboardHTML(version) {
         <div class="settings-tabs">
           <button class="s-tab active" id="stab-account" onclick="switchSettingsTab('account')">👤 Account</button>
           <button class="s-tab" id="stab-settings" onclick="switchSettingsTab('settings')">⚙️ Preferences</button>
+          <button class="s-tab" id="stab-local" onclick="switchSettingsTab('local')">Local Coding</button>
           <button class="s-tab" id="stab-skills" onclick="switchSettingsTab('skills')">📜 Skills</button>
           <button class="s-tab" id="stab-providers" onclick="switchSettingsTab('providers')">🤖 AI Providers</button>
           <button class="s-tab" id="stab-observability" onclick="switchSettingsTab('observability')">🔭 Observability</button>
@@ -1251,6 +1257,7 @@ export function renderDashboardHTML(version) {
           </div>
         </div>
 
+        ${localCodingPanelHTML()}
         <!-- Settings panel (existing content) -->
         <div class="s-tab-panel" id="spanel-settings">
 
@@ -3660,13 +3667,14 @@ document.getElementById('settingsModal').addEventListener('click', function (e)
 // ─── Skills Tab JS ───────────────────────────────────────────
 var _skillsCache = {}; // role → content cache
 function switchSettingsTab(tab) {
-    ['account', 'settings', 'skills', 'providers', 'observability'].forEach(function (t) {
+    ['account', 'settings', 'local', 'skills', 'providers', 'observability'].forEach(function (t) {
         document.getElementById('stab-' + t).classList.toggle('active', t === tab);
         document.getElementById('spanel-' + t).classList.toggle('active', t === tab);
     });
     if (tab === 'account') {
         loadIdentityChip();
     }
+    if (tab === 'local') loadLocalCoding(true);
     if (tab === 'skills') {
         var role = document.getElementById('skillRoleSelect').value;
         loadSkillForRole(role);
@@ -4848,6 +4856,7 @@ function renderIntentHealthCard(data) {
     container.innerHTML = html;
 }
 
+${localCodingScript()}
 </script>
 </body>
 </html>`;

package/dist/storage/configStorage.js

@@ -325,10 +325,10 @@ export async function getSessionContextReceipt(conversationHash, projectHash) {
         return null;
     }
 }
-export async function getSetting(key, defaultValue = "") {
+export async function getSetting(key, defaultValue = "", options = {}) {
     await initConfigStorage();
     // Serve from cache when warm (the common case after startup).
-    if (settingsCache && key in settingsCache) {
+    if (!options.fresh && settingsCache && key in settingsCache) {
         return settingsCache[key];
     }
     const client = getClient();

package/dist/tools/prismInferHandler.js

@@ -45,6 +45,9 @@ import { recordInference, recordThinkOnlyRetry, formatInferenceMetrics, estimate
 import { appendInferMetric } from "../storage/inferMetricsLedger.js";
 import { getStorage } from "../storage/index.js";
 import { getSetting } from "../storage/configStorage.js";
+import { localCodingPreference, resolveLocalCodingBackend } from "../utils/localCodingPreference.js";
+import { isLocalCodingModelId, resolveLocalCodingModel } from "../utils/localCodingSettings.js";
+import { selectedOllamaCodingModel } from "../utils/ollamaCodingModels.js";
 import { DEFAULT_PRISM_ROUTE_TOOLS, applyLocalRouteContract, isRouteToolName, parseRouteOutput, routeServesProse, validatePortalRouteGuardOutcome, } from "../utils/routeContract.js";
 const INFER_CONTEXT_DEPTHS = new Set(["quick", "standard", "deep"]);
 const LOCAL_WORKER_MEMORY_INSTRUCTION = "You are a bounded local Prism worker. Complete only the requested subtask. " +
@@ -75,6 +78,10 @@ const FAST_TASK_COMPLEXITY_MAX = 3;
 const BALANCED_TASK_COMPLEXITY_MAX = 6;
 const MAX_CODING_REPAIR_ATTEMPTS = 2;
 const MAX_ROUTE_TOOLS = 64;
+const CODING_ROLE_DEFAULTS = {
+    omlx: { maxTokens: 4096, timeoutMs: 600_000 },
+    ollama: { maxTokens: 1024, timeoutMs: 300_000 },
+};
 // ─── Tool Definition ────────────────────────────────────────────
 /**
  * Default system prompt for image requests, applied only when the caller
@@ -598,7 +605,7 @@ export const PRISM_INFER_TOOL = {
         idempotentHint: false,
         openWorldHint: true,
     },
-    description: "Run local inference (Ollama by default). Explicit local_backend=omlx uses authenticated " +
+    description: "Run local inference using the saved coding backend preference. Explicit local_backend overrides it. oMLX uses authenticated " +
         "loopback oMLX for text-only code/reviewer drafts, without Ollama/cloud substitution or final sign-off. " +
         "Owns model selection across 27B / 9B / 4B / 2B using an explicit `model_ceiling` or " +
         "the caller's `task_complexity`, then validates loaded memory size, model context, " +
@@ -654,7 +661,7 @@ export const PRISM_INFER_TOOL = {
             },
             max_tokens: {
                 type: "number",
-                description: "Max output tokens (default 1024, hard cap 8192).",
+                description: "Output cap 8192, default 1024. With local_role: oMLX defaults 4096.",
                 default: 1024,
             },
             temperature: {
@@ -664,12 +671,13 @@ export const PRISM_INFER_TOOL = {
             },
             local_backend: {
                 type: "string", enum: ["ollama", "omlx"],
-                description: "Default Ollama; explicit oMLX is text-only code mode, no backend substitution.",
+                description: "Override coding backend; oMLX is text-only. No substitution.",
             },
             local_model: {
                 type: "string",
-                description: "Explicit oMLX only: exact advertised model ID; otherwise use trusted local configuration.",
+                description: "Installed code model override; unavailable models refuse.",
             },
+            local_role: { type: "string", enum: ["coder", "reviewer"], description: "Coding role; default coder." },
             model_ceiling: {
                 type: "string",
                 enum: ["27b", "9b", "4b", "2b"],
@@ -679,12 +687,11 @@ export const PRISM_INFER_TOOL = {
                 type: "number",
                 minimum: 1,
                 maximum: 10,
-                description: "1-10 workload hint prism_infer (not the task router) uses to pick the initial " +
-                    "local tier and thinking mode; explicit model_ceiling/think win.",
+                description: "1-10 tier/thinking hint for prism_infer; explicit model_ceiling/think win.",
             },
             project: {
                 type: "string",
-                description: "Project whose dashboard-depth handoff/recent session memory is historical worker context.",
+                description: "Historical project memory; dashboard depth.",
             },
             context_depth: {
                 type: "string",
@@ -701,7 +708,7 @@ export const PRISM_INFER_TOOL = {
             },
             timeout_ms: {
                 type: "number",
-                description: "Timeout override. Ollama: 27B 120s, 9B 60s, 4B 20s, 2B 15s. oMLX generation/check budget: 300s.",
+                description: "Milliseconds. Explicit local_role: oMLX 600s/Ollama 300s; otherwise legacy timeouts.",
             },
             evidence: {
                 type: "array",
@@ -863,7 +870,9 @@ export function isPrismInferArgs(args) {
         return false;
     if (a.local_backend !== undefined && a.local_backend !== "ollama" && a.local_backend !== "omlx")
         return false;
-    if (a.local_model !== undefined && (a.local_backend !== "omlx" || typeof a.local_model !== "string" || !a.local_model.trim()))
+    if (a.local_role !== undefined && (a.mode !== "code" || (a.local_role !== "coder" && a.local_role !== "reviewer") || (Array.isArray(a.images) && a.images.length > 0)))
+        return false;
+    if (a.local_model !== undefined && (a.mode !== "code" || !isLocalCodingModelId(a.local_model) || (Array.isArray(a.images) && a.images.length > 0)))
         return false;
     if (a.local_backend === "omlx" && (a.mode !== "code" || (Array.isArray(a.images) && a.images.length > 0)))
         return false;
@@ -1099,9 +1108,28 @@ export async function waitForOllamaUnloadDrain(listLoaded, initial, timeoutMs =
     }
     throw new OmlxError("omlx_ollama_unload_incomplete");
 }
-async function strictLoaded(url) {
+export function isOllamaConnectionRefused(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.code === "ECONNREFUSED")
+        return true;
+    if (error instanceof AggregateError)
+        return error.errors.length > 0 && error.errors.every(isOllamaConnectionRefused);
+    return error.cause !== undefined && isOllamaConnectionRefused(error.cause);
+}
+export async function strictLoaded(url, fetchImpl = fetch) {
+    let response;
+    try {
+        response = await fetchImpl(`${url}/api/ps`, { signal: AbortSignal.timeout(3_000), redirect: "error" });
+    }
+    catch (error) {
+        // A closed local listener needs no daemon startup. Timeouts, DNS errors,
+        // HTTP errors and malformed state are unknown and still refuse.
+        if (isOllamaConnectionRefused(error))
+            return new Set();
+        throw new OmlxError("omlx_ollama_state_unavailable");
+    }
     try {
-        const response = await fetch(`${url}/api/ps`, { signal: AbortSignal.timeout(3_000), redirect: "error" });
         if (!response.ok)
             throw new Error();
         const data = await response.json();
@@ -1230,8 +1258,8 @@ const templateOverheadCache = new Map();
  * Returns null when unprobeable, and the caller keeps the old literal — an
  * unmeasurable overhead must not become a zero.
  */
-export async function probeTemplateOverhead(url, model, hasSystem) {
-    const key = `${model}::${hasSystem}`;
+export async function probeTemplateOverhead(url, model, hasSystem, numCtx) {
+    const key = `${url}::${model}::${hasSystem}::${numCtx ?? "default"}`;
     if (templateOverheadCache.has(key))
         return templateOverheadCache.get(key) ?? null;
     try {
@@ -1246,7 +1274,7 @@ export async function probeTemplateOverhead(url, model, hasSystem) {
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
                 model, messages, stream: false, think: false,
-                options: { num_predict: 1, temperature: 0 },
+                options: { num_predict: 1, temperature: 0, ...(numCtx === undefined ? {} : { num_ctx: numCtx }) },
             }),
             // Short, because this must never gate a request: a live ollama
             // answers a one-character prompt in milliseconds, and anything
@@ -1360,7 +1388,7 @@ export async function groundAnswer(o) {
                     messages,
                     stream: false,
                     think: withThinking,
-                    options: { num_predict: tokens, temperature: 0 },
+                    options: { num_predict: tokens, temperature: 0, ...(o.numCtx === undefined ? {} : { num_ctx: o.numCtx }) },
                 }),
                 signal: AbortSignal.timeout(timeoutMs),
                 // The conversation must not follow a redirect off this machine.
@@ -1486,7 +1514,7 @@ export async function probeVision(url, model) {
  * that copied one layer of production and assumed the rest; measuring against a
  * hand-rolled copy of this function would repeat that.
  */
-export async function callOllamaGenerate(url, model, prompt, system, maxTokens, temperature, timeoutMs, think, images, history) {
+export async function callOllamaGenerate(url, model, prompt, system, maxTokens, temperature, timeoutMs, think, images, history, contextTokens) {
     try {
         // The caller's system message, or — when there is none — an empty one
         // for a model whose Modelfile bakes a SYSTEM, so the baked tool-routing
@@ -1505,7 +1533,7 @@ export async function callOllamaGenerate(url, model, prompt, system, maxTokens,
             messages,
             stream: false,
             ...(think !== undefined ? { think } : {}),
-            options: { num_predict: maxTokens, temperature },
+            options: { num_predict: maxTokens, temperature, ...(contextTokens === undefined ? {} : { num_ctx: contextTokens }) },
         };
         const res = await fetch(`${url}/api/chat`, {
             method: "POST",
@@ -1928,6 +1956,37 @@ const _evictionMutex = (() => {
 })();
 export async function runInfer(args, deps) {
     const started = Date.now();
+    // Backend and model are independent overrides. Resolve before taking a
+    // device lease; never infer the reviewer role from prose or system text.
+    const intercepted = [...(args.messages ?? []).filter(turn => turn.role === "user").map(turn => turn.content), args.prompt].some(text => Boolean(checkInputSafety(text)));
+    if (!intercepted && args.mode === "code" && !args.images?.length && deps.codingPreference && !(args.local_backend && args.local_model)) {
+        let preference;
+        try {
+            preference = await deps.codingPreference(args.local_role ?? "coder", args.local_backend);
+        }
+        catch {
+            const reason = "local_coding_preference_invalid";
+            if (args.escalation === "report")
+                return { output: "", backend: "refused", model_picked: null,
+                    ram_free_mb: Math.round(deps.freemem() / 1024 ** 2), latency_ms: Date.now() - started, used_cloud: false,
+                    attempts: [{ tier: "preference", reason }], gate_outcome: { status: "refused", reason, served_anyway: false } };
+            throw new Error(`prism_infer: ${reason}`);
+        }
+        // Auto eligibility uses the same plan snapshot as the later gate,
+        // before choosing a device lease. Explicit selections remain strict.
+        if (preference.effective === "auto")
+            deps = { ...deps, entitlements: deps.entitlements ?? await getEntitlements() };
+        const selectionArgs = preference.effective === "auto"
+            ? { ...args, model_ceiling: clampCeiling(args.model_ceiling ?? "27b", deps.entitlements.model_ceiling) } : args;
+        const backend = resolveLocalCodingBackend(selectionArgs, preference);
+        const model = resolveLocalCodingModel(preference, backend, args.local_role ?? "coder", args.local_model);
+        args = { ...args, local_backend: backend,
+            ...(model ? { local_model: model } : {}) };
+    }
+    if (args.local_role) {
+        const defaults = CODING_ROLE_DEFAULTS[args.local_backend === "omlx" ? "omlx" : "ollama"];
+        args = { ...args, max_tokens: args.max_tokens ?? defaults.maxTokens, timeout_ms: args.timeout_ms ?? defaults.timeoutMs };
+    }
     return withInferenceResourceLease(args.local_backend === "omlx", async () => {
         let releaseDevice;
         const runtime = args.local_backend === "omlx" ? deps.omlx : undefined;
@@ -2238,30 +2297,36 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
         }
         attempts.push({ tier: "omlx", reason: "authenticated_model_detected" });
     }
-    const installed = await deps.listTags();
-    const loaded = await deps.listLoaded();
-    if (omlxTarget && installed === null)
-        throw new Error("prism_infer: omlx_classifier_unavailable");
-    // Explicit oMLX: timeout_ms bounds the whole call, the Ollama unload and
-    // classification included.
+    const installed = omlxTarget ? new Set() : await deps.listTags();
+    const loaded = omlxTarget ? new Set() : await deps.listLoaded();
+    let selectedOllama;
+    if (!omlxTarget && args.local_model) {
+        if (mode !== "code" || args.images?.length)
+            throw new Error("prism_infer: selected models require text-only code mode");
+        try {
+            if (installed === null)
+                throw new Error("ollama_model_inventory_unavailable");
+            if (!installed.has(args.local_model))
+                throw new Error("ollama_model_not_installed");
+            selectedOllama = await (deps.selectedOllamaModel ?? selectedOllamaCodingModel)(deps.ollamaUrl, args.local_model, clampCeiling(args.model_ceiling ?? "27b", ent.model_ceiling));
+        }
+        catch (error) {
+            const reason = error instanceof Error && /^ollama_model_[a-z_]+$/.test(error.message) ? error.message : "ollama_model_metadata_unavailable";
+            attempts.push({ tier: args.local_model, reason });
+            if (wantReport)
+                return refusedResult(reason);
+            throw new Error(`prism_infer: ${reason}; selected coding model will not be substituted`);
+        }
+    }
+    // oMLX classification and generation share one bounded deadline.
     const omlxDeadline = Date.now() + (args.timeout_ms ?? 300_000);
-    // Ollama is unloaded during an explicit oMLX call (owner, 2026-10-15; this
-    // replaces plan section 4's "never evict another Ollama user's weights").
-    // Under the device lease, before classification: unload every resident
-    // model reversibly (the weights stay on disk and reload on the next Ollama
-    // call) and wait until Ollama reports none. A failed unload, a model that
-    // does not drain, or a newcomer loading meanwhile refuses. After this, a
-    // model that appears is refused per read by guardedOmlxGenerate.
+    // Observe contention without starting Ollama or evicting another job.
+    // Guarded reads keep monitoring for newcomers throughout generation.
     if (omlxTarget && omlxRuntime) {
         let residency = null;
         try {
-            const initial = new Set(await omlxRuntime.listLoaded());
-            for (const model of initial)
-                await omlxRuntime.unload(model);
-            if (initial.size > 0) {
-                await waitForOllamaUnloadDrain(() => omlxRuntime.listLoaded(), initial);
-                attempts.push({ tier: "omlx", reason: `omlx_ollama_unloaded:${initial.size}` });
-            }
+            if ((await omlxRuntime.listLoaded()).size > 0)
+                throw new OmlxError("omlx_memory_contention");
         }
         catch (error) {
             residency = error instanceof OmlxError ? error.reason : "omlx_ollama_state_unavailable";
@@ -2731,7 +2796,8 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
                 ...(history ?? []), { role: "user", content: prompt }];
             return guardedOmlxGenerate(omlxRuntime, omlxTarget, { messages, maxTokens, temperature: args.temperature, timeoutMs: Math.min(timeoutMs, omlxDeadline - Date.now()), think }, deps.freemem);
         }
-        : deps.callLocal;
+        : selectedOllama ? (url, model, prompt, system, maxTokens, temperature, timeoutMs, think, images, history) => deps.callLocal(url, model, prompt, system, maxTokens, temperature, timeoutMs, think, images, history, selectedOllama.ctxTokens)
+            : deps.callLocal;
     // A second read ran the 9b after free RAM and the warm set were read
     // above (and may have loaded it, or found it unloaded since); eviction and
     // the tier RAM gate below must see the machine as it is now. Every other
@@ -2749,20 +2815,20 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
     // A local answer to a conversation the answer check rejected or did not check: never served as answer text.
     let withheldReason = null;
     if (installed) {
-        const servingTiers = omlxTarget ? [{ tag: omlxTarget.model, weightsGb: 0, minFreeGb: OMLX_MIN_AVAILABLE_BYTES / 1024 ** 3, ctxTokens: omlxTarget.contextTokens }] : MODEL_TIERS;
+        const servingTiers = omlxTarget ? [{ tag: omlxTarget.model, weightsGb: 0, minFreeGb: OMLX_MIN_AVAILABLE_BYTES / 1024 ** 3, ctxTokens: omlxTarget.contextTokens }] : selectedOllama ? [selectedOllama] : MODEL_TIERS;
         // F4 fix: guard ceiling-not-found — Math.max(0,-1) silently targets tier 0 (27b).
         // Instead of defaulting to the largest tier, treat not-found as "no ceiling" (start=0).
         const ceilIdx = effectiveCeiling
             ? MODEL_TIERS.findIndex(t => t.tag.endsWith(`:${effectiveCeiling}`))
             : -1;
-        const ceilStart = omlxTarget ? 0 : ceilIdx >= 0 ? ceilIdx : 0;
+        const ceilStart = omlxTarget || selectedOllama ? 0 : ceilIdx >= 0 ? ceilIdx : 0;
         // Auto-evict: if the ceiling tier is installed but not warm and prism's
         // own smaller tier models are warm, unload them to make room.
         // Operates only on prism tier models — never evicts arbitrary Ollama models
         // the caller doesn't own (F1). Uses an in-process mutex to prevent a
         // concurrent request from evicting a model mid-inference (F3).
-        let freeAfterEvict = omlxTarget ? deps.freemem() : genFreeBytes;
-        if (!omlxTarget && genLoaded && genLoaded.size > 0) {
+        let freeAfterEvict = omlxTarget || selectedOllama ? deps.freemem() : genFreeBytes;
+        if (!omlxTarget && !selectedOllama && genLoaded && genLoaded.size > 0) {
             const ceilTier = MODEL_TIERS[ceilIdx >= 0 ? ceilIdx : 0];
             const ceilName = ceilTier ? resolveOllamaName(ceilTier.tag, installed) : null;
             const ceilInstalled = ceilName ? installed.has(ceilName) : false;
@@ -2908,14 +2974,14 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
             // or namespaced (`dcostenco/prism-coder:27b`, the form `ollama pull`
             // produces from a HF repo). resolveOllamaName returns the actual
             // name Ollama knows so /api/generate finds the model.
-            const ollamaName = omlxTarget ? omlxTarget.model : resolveOllamaName(tier.tag, installed);
+            const ollamaName = omlxTarget ? omlxTarget.model : selectedOllama ? selectedOllama.tag : resolveOllamaName(tier.tag, installed);
             if (!omlxTarget && !installed.has(ollamaName)) {
                 attempts.push({ tier: tier.tag, reason: "not_pulled" });
                 continue;
             }
             // RAM gate — but skip the check if the tier is already warm in
             // Ollama. Reused models don't reallocate weight buffers.
-            const isWarm = genLoaded.has(ollamaName);
+            const isWarm = !selectedOllama && genLoaded.has(ollamaName);
             if (!isWarm && freeAfterEvict < tier.minFreeGb * (1024 ** 3)) {
                 attempts.push({ tier: tier.tag, reason: "ram_insufficient" });
                 continue;
@@ -2946,7 +3012,7 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
             // unprobeable means fall back to the table, never unlock.
             let liveCtx = null;
             try {
-                liveCtx = omlxTarget ? omlxTarget.contextTokens : await (deps.probeNumCtx ?? probeNumCtx)(deps.ollamaUrl, ollamaName);
+                liveCtx = omlxTarget ? omlxTarget.contextTokens : selectedOllama ? selectedOllama.ctxTokens : await (deps.probeNumCtx ?? probeNumCtx)(deps.ollamaUrl, ollamaName);
             }
             catch {
                 liveCtx = null;
@@ -2966,7 +3032,7 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
             const MAX_TEMPLATE_OVERHEAD = 1_300;
             let CTX_TEMPLATE_MARGIN = 64;
             if (!omlxTarget && promptBodyEst + MAX_TEMPLATE_OVERHEAD > effectiveCtx) {
-                const probed = await (deps.probeTemplateOverhead ?? probeTemplateOverhead)(deps.ollamaUrl, ollamaName, effectiveSystem != null);
+                const probed = await (deps.probeTemplateOverhead ?? probeTemplateOverhead)(deps.ollamaUrl, ollamaName, effectiveSystem != null, ...(selectedOllama ? [selectedOllama.ctxTokens] : []));
                 if (probed != null)
                     CTX_TEMPLATE_MARGIN = probed;
             }
@@ -3248,9 +3314,9 @@ async function runInferAfterInputSafety(args, deps, t0, temperature) {
                             // overhead, the reasoning budget and the one follow-up turn: a
                             // request Ollama truncates would let the check pass an answer
                             // against a conversation it only partly read.
-                            const runtimeCtx = omlxTarget ? omlxTarget.contextTokens : await (deps.probeLoadedContext ?? probeLoadedContext)(deps.ollamaUrl, ollamaName).catch(() => null);
+                            const runtimeCtx = omlxTarget ? omlxTarget.contextTokens : selectedOllama ? selectedOllama.ctxTokens : await (deps.probeLoadedContext ?? probeLoadedContext)(deps.ollamaUrl, ollamaName).catch(() => null);
                             const checkCtx = runtimeCtx ?? effectiveCtx;
-                            const overhead = omlxTarget ? MAX_TEMPLATE_OVERHEAD : (await Promise.resolve((deps.probeTemplateOverhead ?? probeTemplateOverhead)(deps.ollamaUrl, ollamaName, true)).catch(() => null)) ?? MAX_TEMPLATE_OVERHEAD;
+                            const overhead = omlxTarget ? MAX_TEMPLATE_OVERHEAD : (await Promise.resolve((deps.probeTemplateOverhead ?? probeTemplateOverhead)(deps.ollamaUrl, ollamaName, true, ...(selectedOllama ? [selectedOllama.ctxTokens] : []))).catch(() => null)) ?? MAX_TEMPLATE_OVERHEAD;
                             const need = answerGroundingBytes(policy, args.messages ?? [], args.prompt, output)
                                 + estimateImageTokens(resolvedImages?.length ?? 0) + overhead
                                 + (ANSWER_GROUNDING_THINK ? ANSWER_GROUNDING_THINK_TOKENS : ANSWER_GROUNDING_OUTPUT_TOKENS)
@@ -3547,6 +3613,7 @@ async function applyVerification(draft, args, deps, partial) {
  */
 export function productionInferDeps() {
     return {
+        codingPreference: localCodingPreference,
         omlx: createOmlxRuntime({
             listLoaded: () => strictLoaded(PRISM_LOCAL_LLM_URL),
             unload: model => unloadOllamaModel(PRISM_LOCAL_LLM_URL, model),

package/dist/utils/localCodingPreference.js

@@ -0,0 +1,24 @@
+import { configuredOmlxModel } from "./omlxProvider.js";
+import { isLocalCodingBackend, readLocalCodingSettings, resolveLocalCodingModel } from "./localCodingSettings.js";
+export { LOCAL_CODING_BACKENDS, isLocalCodingBackend } from "./localCodingSettings.js";
+/** Read on each task so a dashboard save applies without restarting a host. */
+export async function localCodingPreference(role = "coder", explicitBackend) {
+    const settings = await readLocalCodingSettings(), stored = settings.backend;
+    const override = explicitBackend ? undefined : process.env.PRISM_LOCAL_CODING_BACKEND;
+    if (override !== undefined && !isLocalCodingBackend(override))
+        throw new Error("local_coding_override_invalid");
+    const model = resolveLocalCodingModel(settings, "omlx", "coder");
+    const effective = explicitBackend ?? override ?? stored;
+    // A broken configured server is an error, not permission to change backend.
+    const configured = effective === "auto" ? Boolean(await configuredOmlxModel(resolveLocalCodingModel(settings, "omlx", role))) : false;
+    return { saved: stored, effective, envOverride: override ?? null, model: model || undefined, models: settings.models, configured };
+}
+export function resolveLocalCodingBackend(args, preference) {
+    if (args.local_backend)
+        return args.local_backend;
+    if (args.mode !== "code" || args.images?.length)
+        return "ollama";
+    if (preference.effective === "auto" && args.model_ceiling && args.model_ceiling !== "27b")
+        return "ollama";
+    return preference.effective === "omlx" || (preference.effective === "auto" && preference.configured) ? "omlx" : "ollama";
+}

package/dist/utils/localCodingSettings.js

@@ -0,0 +1,55 @@
+import { getSetting, setSetting } from "../storage/configStorage.js";
+export const LOCAL_CODING_BACKENDS = ["auto", "omlx", "ollama"];
+export const LOCAL_CODING_ROLES = ["coder", "reviewer"];
+// Older Prism versions reject unknown keys. A single versioned record keeps
+// new saves atomic without corrupting their legacy config or rollback state.
+const KEY = "local_coding_config_v2";
+const LEGACY_KEY = "local_coding_config";
+export function isLocalCodingModelId(value) {
+    return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(value);
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("local_coding_preference_invalid");
+    return value;
+}
+function parseModels(value) {
+    const input = record(value), models = {};
+    for (const backend of Object.keys(input)) {
+        if (backend !== "omlx" && backend !== "ollama")
+            throw new Error("local_coding_preference_invalid");
+        const roles = record(input[backend]);
+        models[backend] = {};
+        for (const role of Object.keys(roles)) {
+            if ((role !== "coder" && role !== "reviewer") || !isLocalCodingModelId(roles[role]))
+                throw new Error("local_coding_preference_invalid");
+            models[backend][role] = roles[role];
+        }
+    }
+    return models;
+}
+export function isLocalCodingBackend(value) {
+    return LOCAL_CODING_BACKENDS.some(backend => backend === value);
+}
+export function parseLocalCodingSettings(value) {
+    const input = record(value);
+    if (!Object.hasOwn(input, "backend") || !Object.hasOwn(input, "source")
+        || Object.keys(input).some(key => !["backend", "source", "model", "models"].includes(key))
+        || !isLocalCodingBackend(input.backend) || (input.source !== "existing" && input.source !== "managed")
+        || (Object.hasOwn(input, "model") && !isLocalCodingModelId(input.model)))
+        throw new Error("local_coding_preference_invalid");
+    return { backend: input.backend, source: input.source,
+        ...(Object.hasOwn(input, "model") ? { model: input.model } : {}),
+        ...(Object.hasOwn(input, "models") ? { models: parseModels(input.models) } : {}) };
+}
+/** Exact assignments: sharing an ID is allowed, never inferred across roles. */
+export function resolveLocalCodingModel(settings, backend, role, explicitModel) {
+    return explicitModel ?? settings.models?.[backend]?.[role] ?? (backend === "omlx" && role === "coder" ? settings.model : undefined);
+}
+export async function readLocalCodingSettings() {
+    const raw = await getSetting(KEY, "", { fresh: true }) || await getSetting(LEGACY_KEY, "", { fresh: true });
+    return raw ? parseLocalCodingSettings(JSON.parse(raw)) : { backend: "auto", source: "existing" };
+}
+export async function saveLocalCodingSettings(value) {
+    await setSetting(KEY, JSON.stringify(parseLocalCodingSettings(value)));
+}

package/dist/utils/ollamaCodingModels.js

@@ -0,0 +1,93 @@
+import { PRISM_LOCAL_LLM_URL } from "../config.js";
+import { isLocalCodingModelId } from "./localCodingSettings.js";
+const GIB = 1024 ** 3;
+const MAX_MODELS = 1024;
+const MAX_METADATA_BYTES = 1024 * 1024;
+const CODING_CONTEXT_LIMIT = 4096;
+const positive = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+/** Read-only metadata probes; never pulls or loads a model. */
+async function metadata(url, fetchImpl, model) {
+    const response = await fetchImpl(url, { ...(model === undefined ? {} : {
+            method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model }),
+        }), redirect: "error", signal: AbortSignal.timeout(3000) });
+    if (!response.ok || !response.body)
+        throw new Error("ollama_model_metadata_unavailable");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            size += part.value.byteLength;
+            if (size > MAX_METADATA_BYTES)
+                throw new Error("ollama_model_metadata_invalid");
+            chunks.push(part.value);
+        }
+    }
+    finally {
+        void reader.cancel().catch(() => { });
+    }
+    const data = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        throw new Error("ollama_model_metadata_invalid");
+    return data;
+}
+export async function inspectOllamaCodingModels(url = PRISM_LOCAL_LLM_URL, fetchImpl = fetch) {
+    const [tags, ps] = await Promise.all([metadata(`${url}/api/tags`, fetchImpl), metadata(`${url}/api/ps`, fetchImpl)]);
+    if (!Array.isArray(tags.models) || tags.models.length > MAX_MODELS || !Array.isArray(ps.models) || ps.models.length > MAX_MODELS)
+        throw new Error("ollama_model_inventory_invalid");
+    const ids = new Set();
+    return tags.models.map((model) => {
+        if (!model || !isLocalCodingModelId(model.name) || ids.has(model.name))
+            throw new Error("ollama_model_inventory_invalid");
+        ids.add(model.name);
+        const loaded = ps.models.find((entry) => entry && (entry.name === model.name || entry.model === model.name));
+        return { id: model.name, loaded: Boolean(loaded),
+            ...(positive(model.size) ? { weightBytes: model.size } : {}),
+            ...(positive(loaded?.size_vram) ? { loadedBytes: loaded.size_vram } : {}),
+            ...(positive(loaded?.context_length) ? { contextTokens: loaded.context_length } : {}) };
+    });
+}
+/** A selected model gets one exact attempt, not a walk through named tiers.
+ * Sizes plus overhead are an estimate, not a guarantee about peak RAM. */
+export async function selectedOllamaCodingModel(url, id, ceiling, fetchImpl = fetch) {
+    if (!isLocalCodingModelId(id))
+        throw new Error("ollama_model_id_invalid");
+    const models = await inspectOllamaCodingModels(url, fetchImpl);
+    const selected = models.find(model => model.id === id);
+    if (!selected)
+        throw new Error("ollama_model_not_installed");
+    const show = await metadata(`${url}/api/show`, fetchImpl, id);
+    const info = show.model_info;
+    const params = info?.["general.parameter_count"];
+    const architecture = info?.["general.architecture"];
+    const nativeContext = typeof architecture === "string" ? info?.[`${architecture}.context_length`] : undefined;
+    if (!selected.weightBytes || !positive(params) || !positive(nativeContext)
+        || !Array.isArray(show.capabilities) || !show.capabilities.includes("completion"))
+        throw new Error("ollama_model_metadata_incomplete");
+    // Entitlement tiers name nominal billions, not exact tensor counts.
+    // Rounding admits e.g. 27.4B as 27B without making the top tier unlimited.
+    const maxBillions = /^(2|4|9|27)b$/.test(ceiling) ? Number(ceiling.slice(0, -1)) : 0;
+    if (!maxBillions || Math.round(params / 1e9) > maxBillions)
+        throw new Error("ollama_model_ceiling");
+    const ctxTokens = Math.min(nativeContext, CODING_CONTEXT_LIMIT);
+    const layers = info[`${architecture}.block_count`], heads = info[`${architecture}.attention.head_count_kv`];
+    const embedding = info[`${architecture}.embedding_length`], attentionHeads = info[`${architecture}.attention.head_count`];
+    if (![layers, heads, embedding, attentionHeads].every(positive))
+        throw new Error("ollama_model_memory_unknown");
+    const rawKeyLength = info[`${architecture}.attention.key_length`], rawValueLength = info[`${architecture}.attention.value_length`];
+    if ((rawKeyLength !== undefined && !positive(rawKeyLength)) || (rawValueLength !== undefined && !positive(rawValueLength)))
+        throw new Error("ollama_model_memory_unknown");
+    // Some architectures declare independent K/V dimensions. Never shrink the
+    // fp16 estimate below either the declared or the derived head dimension.
+    const derivedHead = embedding / attentionHeads;
+    const keyLength = Math.max(derivedHead, rawKeyLength ?? derivedHead), valueLength = Math.max(derivedHead, rawValueLength ?? derivedHead);
+    const kvBytes = layers * heads * (keyLength + valueLength) * ctxTokens * 2;
+    const requiredBytes = Math.max(selected.weightBytes * 1.5, selected.weightBytes + kvBytes + 2 * GIB);
+    if (!Number.isFinite(requiredBytes) || requiredBytes <= 0)
+        throw new Error("ollama_model_memory_unknown");
+    return { tag: id, weightsGb: selected.weightBytes / GIB, minFreeGb: requiredBytes / GIB, ctxTokens,
+        prefersThinking: show.capabilities.includes("thinking") };
+}