prism-mcp-server 19.0.1 → 19.1.0

package/README.md

@@ -11,7 +11,7 @@
   <img src="docs/v11_hivemind_multi_agent_dashboard.jpg" alt="Prism Coder — Mind Palace Dashboard with Knowledge Graph and Multi-Agent Hivemind" width="700" />
 </p>
 
-Prism Coder is an [MCP server](https://modelcontextprotocol.io) that gives Claude, Cursor, and other AI tools long-term memory that survives across sessions. It ships with the open-weight `prism-coder` model fleet (2B–32B) for fast, offline tool-routing — no cloud required.
+Prism Coder is an [MCP server](https://modelcontextprotocol.io) that gives Claude, Cursor, and other AI tools long-term memory that survives across sessions. It ships with the open-weight `prism-coder` model fleet (2B–27B) for fast, offline tool-routing — no cloud required.
 
 **No account needed. No API keys. Runs on your machine.**  
 A paid subscription adds cloud sync, higher model tiers, and team features through the [Synalux portal](https://synalux.ai).
@@ -41,7 +41,7 @@ Open Claude Desktop or Cursor and your agent now has memory backed by a local SQ
 ollama pull dcostenco/prism-coder:2b    # 2.3 GB · mobile / lightweight (99.1% routing accuracy)
 ollama pull dcostenco/prism-coder:4b    # 3.4 GB · verifier (100% accuracy)
 ollama pull dcostenco/prism-coder:9b    # 5.8 GB · default router (100% accuracy, Qwen3.5)
-ollama pull dcostenco/prism-coder:32b   # 19 GB  · complex tasks (100% accuracy)
+ollama pull dcostenco/prism-coder:27b   # 16 GB  · complex tasks (100% accuracy)
 ```
 
 Prism detects both the namespaced (`dcostenco/prism-coder:9b`) and bare (`prism-coder:9b`) Ollama tags automatically.
@@ -145,14 +145,16 @@ The free tier runs entirely on your machine. Paid tiers add cloud sync through t
 
 ## Models
 
-The `prism-coder` fleet uses Qwen3.5 for MCP tool-routing. The 9B is fine-tuned with LoRA (r=128, all 64 layers including DeltaNet); the 2B and 4B use stock Qwen3.5-4B at different quantization levels. They are **not** general-purpose chat models — they route reliably and run offline; Claude and other frontier models remain better at reasoning, coding, and open-domain work. The intended pattern is local routing with an optional cloud fallback for hard cases.
+The `prism-coder` fleet uses Qwen3.5 for MCP tool-routing AND general inference. The 9B and 27B are fine-tuned with LoRA (r=128, all 64 layers including DeltaNet); the 2B and 4B use stock Qwen3.5-4B at different quantization levels. The 27B scored 100% on BFCL function-calling and 100% on an internal 15-problem coding eval at $0 inference cost.
+
+`prism_infer` supports three modes: `route` (tool routing, fast, nothink), `chat` (conversation with thinking), and `code` (code generation with thinking). In chat/code modes, the model uses `<think>` blocks for chain-of-thought reasoning, which are stripped before the response is served. If the local model fails a quality gate (empty, think-only, or truncated), paid tiers automatically escalate to Claude via the Synalux portal.
 
 | Model | Ollama tag | Size | [BFCL](https://gorilla.cs.berkeley.edu/blogs/12_bfcl_v3_multi_turn.html) Accuracy | Role | Tier |
 |---|---|---|---|---|---|
 | Qwen3.5-4B Q3_K_M | `prism-coder:2b` | 2.3 GB | 99.1% × 3 seeds | iPhone / mobile first gate | Free |
 | Qwen3.5-4B Q4_K_M | `prism-coder:4b` | 3.4 GB | 100% × 3 seeds | Verifier | Free |
 | Qwen3.5-9B (LoRA) | `prism-coder:9b` | 5.8 GB | 100% × 3 seeds | Default router | Standard+ |
-| prism-coder:32b | `prism-coder:32b` | 19 GB | 100% × 3 seeds | Complex tasks | Advanced+ |
+| Qwen3.5-27B (LoRA) | `prism-coder:27b` | 16 GB | 100% × 3 seeds | Quality tier (DeltaNet, 28.5 tok/s) | Advanced+ |
 
 Weights: [huggingface.co/dcostenco](https://huggingface.co/dcostenco) (public GGUF). Latency depends on model size and hardware — see [Benchmarks](#benchmarks) to measure it on your own machine rather than trusting a printed number.
 
@@ -162,7 +164,7 @@ Weights: [huggingface.co/dcostenco](https://huggingface.co/dcostenco) (public GG
 query → prism-coder:9b (local router, default)
       → prism-coder:4b (grounding verifier)
       → prism-coder:2b (iPhone / mobile, auto-selected by RAM)
-      → prism-coder:32b (complex tasks, on demand)
+      → prism-coder:27b (complex tasks, on demand)
       → cloud fallback (paid tiers, for max quality)
 ```
 
@@ -189,7 +191,7 @@ Fail-closed on the verified path: when the grounding verifier runs (Standard tie
 ```bash
 git clone https://github.com/dcostenco/prism-coder && cd prism-coder
 pip install anthropic requests
-python3 tests/benchmarks/prism-routing-100/benchmark.py --models 2b 4b 9b 32b
+python3 tests/benchmarks/prism-routing-100/benchmark.py --models 2b 4b 9b 27b
 ```
 
 **Routing eval (115 cases, 12 categories, 3-seed mean).** Routing accuracy includes the deterministic L3 correction layer — the same rules that run in production. On this narrow tool-routing task all fleet models achieve near-perfect accuracy. Be honest with yourself about what that means: the eval is **near-saturated** for this taxonomy — it measures whether the right one of a small set of MCP tools is selected, not general capability. The useful takeaway is **offline routing reliability at zero cost**, not that a 2.3 GB model rivals a frontier model in general.
@@ -197,7 +199,7 @@ python3 tests/benchmarks/prism-routing-100/benchmark.py --models 2b 4b 9b 32b
 | Model | Routing accuracy | Notes |
 |---|---|---|
 | prism-coder:2b (Q3_K_M) | 99.1% × 3 seeds | 1 failure: regex→knowledge_search |
-| prism-coder:4b / 9b / 32b | 100% × 3 seeds | Perfect on all 115 cases |
+| prism-coder:4b / 9b / 27b | 100% × 3 seeds | Perfect on all 115 cases |
 | Claude (frontier, same eval) | ~98% | Stronger everywhere outside this narrow task |
 
 **Memory uplift (LoCoMo-Plus, self-published).** A separate long-context dialogue benchmark ([dcostenco/Locomo-Plus](https://github.com/dcostenco/Locomo-Plus)) measures how much structured memory helps a base model retain multi-day context. Results show large gains when a model is paired with Prism memory versus running raw. Note this benchmark is authored, run, and LLM-judged by this project — treat it as a reproducible demonstration, not an independent third-party result, and run it yourself with the commands in that repo.
@@ -254,7 +256,7 @@ All on-device models are free to run locally via Ollama on every tier. A subscri
 | | **Free** | **Standard** $19/mo | **Advanced** $49/mo | **Enterprise** $99/mo |
 |---|---|---|---|---|
 | Seats | 1 | 1 | up to 5 | up to 25 |
-| Local model ceiling | up to 4b | up to 9b | up to 32b | up to 32b |
+| Local model ceiling | up to 4b | up to 9b | up to 27b | up to 27b |
 | Daily cloud inference | -- | 200 | 2,000 | 100,000 |
 | Cloud Coder (Web IDE) | -- | 100/day | 1,000/day | 100,000/day |
 | Cloud search | -- | 50/day | 500/day | 100,000/day |
@@ -284,6 +286,26 @@ Prism exposes 40+ MCP tools. The core memory loop:
 | `session_detect_drift` | Detect when a session has drifted from its goal |
 | `verify_behavior` | Pre-edit scenario challenge — catch bad changes before they happen |
 | `knowledge_ingest` | Teach Prism a codebase or document |
+| `prism_infer` | Local-first inference (route/chat/code modes, thinking, cloud escalation) |
+
+### `prism_infer` — local-first inference with cloud escalation
+
+```typescript
+prism_infer({
+    prompt: "Write a binary search in Python",
+    mode: "code",        // "route" | "chat" | "code"
+    think: true,          // enable <think> reasoning (default: true for chat/code)
+    model_ceiling: "27b", // use the quality tier
+})
+// → 27B generates code locally ($0), with thinking for quality
+// → If quality gate fails + paid tier → auto-escalate to Claude
+```
+
+| Mode | Think | Model | Use case |
+|------|-------|-------|----------|
+| `route` | Off (fast) | 9B default | MCP tool routing |
+| `chat` | On | 27B preferred | Conversation, reasoning |
+| `code` | On | 27B preferred | Code generation, debugging |
 
 Full TypeScript signatures live in [`src/tools/`](src/tools/); architecture in [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md).
 

package/dist/tools/prismInferHandler.js

@@ -2,7 +2,7 @@
  * prism_infer — local-first inference tool
  * ─────────────────────────────────────────────────────────────
  * Save the caller's cloud tokens by routing to a local prism-coder
- * model via Ollama. Tiers (32B/9B/8B/1.7B) auto-selected by free
+ * model via Ollama. Tiers (27B/9B/8B/1.7B) auto-selected by free
  * RAM, then capped by `model_ceiling` and the set of tags that are
  * actually pulled into Ollama.
  *
@@ -12,7 +12,7 @@
  *   4. On local fail, if cloud_fallback=true:
  *        - exchange synalux_sk_ → JWT (cached)
  *        - POST synalux portal /api/v1/prism-aac/inference
- *        - portal runs its own cascade (9B/32B/Claude by tier)
+ *        - portal runs its own cascade (9B/27B/Claude by tier)
  *   5. Return { output, backend, model_picked, ram_free_mb, latency_ms, used_cloud }
  *
  * `prism_infer` is a thin client. It never calls Anthropic / OpenRouter
@@ -26,13 +26,15 @@ import { PRISM_SYNALUX_BASE_URL, PRISM_LOCAL_LLM_URL, } from "../config.js";
 import { debugLog } from "../utils/logger.js";
 import { getEntitlements, clampCeiling } from "../utils/entitlements.js";
 import { ddLog } from "../utils/ddLogger.js";
+import { stripThink } from "../utils/thinkStrip.js";
+import { passesQualityGate } from "../utils/qualityGate.js";
 // ─── Tool Definition ────────────────────────────────────────────
 export const PRISM_INFER_TOOL = {
     name: "prism_infer",
     description: "Run an inference on a local prism-coder model (Ollama) to save cloud tokens. " +
-        "Picks the largest viable tier — 32B / 9B / 8B / 1.7B — based on free RAM at call time, " +
+        "Picks the largest viable tier — 27B / 9B / 8B / 1.7B — based on free RAM at call time, " +
         "clamped by `model_ceiling` and what is actually pulled in Ollama. " +
-        "Falls through to the synalux portal cloud cascade (9B → 32B → Claude Opus 4.7) " +
+        "Falls through to the synalux portal cloud cascade (9B → 27B → Claude Opus 4.7) " +
         "only when local is unviable AND `cloud_fallback=true`. " +
         "Use this for code generation, summarisation, classification, or any synth task you would " +
         "otherwise hand to the cloud model — it costs $0 when the local hit succeeds.",
@@ -59,8 +61,8 @@ export const PRISM_INFER_TOOL = {
             },
             model_ceiling: {
                 type: "string",
-                enum: ["32b", "9b", "4b", "2b"],
-                description: "Cap the largest tier the picker may select. e.g. '9b' forbids 32B even if RAM allows.",
+                enum: ["27b", "9b", "4b", "2b"],
+                description: "Cap the largest tier the picker may select. e.g. '9b' forbids 27B even if RAM allows.",
             },
             cloud_fallback: {
                 type: "boolean",
@@ -69,7 +71,7 @@ export const PRISM_INFER_TOOL = {
             },
             timeout_ms: {
                 type: "number",
-                description: "Override per-call timeout. Default scales with model size: 32B=120s, 9B=60s, 4B=20s, 1.7B=15s.",
+                description: "Override per-call timeout. Default scales with model size: 27B=120s, 9B=60s, 4B=20s, 1.7B=15s.",
             },
             evidence: {
                 type: "array",
@@ -102,6 +104,20 @@ export const PRISM_INFER_TOOL = {
                 description: "Override the verifier hard timeout. Default 2000 ms.",
                 default: 2000,
             },
+            mode: {
+                type: "string",
+                enum: ["route", "chat", "code"],
+                description: "Execution mode. 'route' (default) for MCP tool routing — fast, nothink. " +
+                    "'chat' for general conversation — uses thinking, escalates to cloud on failure. " +
+                    "'code' for code generation — uses thinking, larger context. " +
+                    "In chat/code modes, prefers the 27B tier and enables <think> reasoning.",
+                default: "route",
+            },
+            think: {
+                type: "boolean",
+                description: "Enable thinking mode (<think> blocks). Default: true for chat/code, false for route. " +
+                    "Thinking improves quality on complex tasks but adds latency (~2-5s).",
+            },
         },
         required: ["prompt"],
     },
@@ -123,7 +139,12 @@ export function isPrismInferArgs(args) {
     if (a.timeout_ms !== undefined && typeof a.timeout_ms !== "number")
         return false;
     if (a.model_ceiling !== undefined &&
-        !["32b", "9b", "4b", "2b"].includes(a.model_ceiling))
+        !["27b", "9b", "4b", "2b"].includes(a.model_ceiling))
+        return false;
+    if (a.mode !== undefined &&
+        !["route", "chat", "code"].includes(a.mode))
+        return false;
+    if (a.think !== undefined && typeof a.think !== "boolean")
         return false;
     if (a.verify !== undefined && typeof a.verify !== "boolean")
         return false;
@@ -146,7 +167,7 @@ export function isPrismInferArgs(args) {
 }
 // ─── Ollama helpers ────────────────────────────────────────────
 const DEFAULT_TIMEOUTS = {
-    "prism-coder:32b": 120_000,
+    "prism-coder:27b": 120_000,
     "prism-coder:9b": 60_000,
     "prism-coder:4b": 20_000,
     "prism-coder:2b": 15_000,
@@ -193,16 +214,20 @@ export async function listOllamaLoaded(url = PRISM_LOCAL_LLM_URL) {
         return new Set();
     }
 }
-async function callOllamaGenerate(url, model, prompt, system, maxTokens, temperature, timeoutMs) {
+async function callOllamaGenerate(url, model, prompt, system, maxTokens, temperature, timeoutMs, think) {
     try {
+        const messages = [];
+        if (system)
+            messages.push({ role: "system", content: system });
+        messages.push({ role: "user", content: prompt });
         const body = {
             model,
-            prompt,
-            ...(system ? { system } : {}),
+            messages,
             stream: false,
+            ...(think !== undefined ? { think } : {}),
             options: { num_predict: maxTokens, temperature },
         };
-        const res = await fetch(`${url}/api/generate`, {
+        const res = await fetch(`${url}/api/chat`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(body),
@@ -214,10 +239,10 @@ async function callOllamaGenerate(url, model, prompt, system, maxTokens, tempera
         const data = (await res.json());
         if (data.error)
             return { ok: false, reason: `ollama_err:${data.error}` };
-        const text = (data.response ?? "").trim();
+        const text = (data.message?.content ?? "").trim();
         if (!text)
             return { ok: false, reason: "empty_response" };
-        return { ok: true, text };
+        return { ok: true, text, doneReason: data.done_reason };
     }
     catch (err) {
         const name = err instanceof Error ? err.name : "Unknown";
@@ -279,8 +304,11 @@ export async function runInfer(args, deps) {
     // Fetch user's plan limits (cached 1hr). Free users without auth
     // get 4b ceiling, 50 calls/day, 512 max tokens.
     const ent = deps.entitlements ?? await getEntitlements();
-    // Clamp model ceiling to what the plan allows
-    const effectiveCeiling = clampCeiling(args.model_ceiling, ent.model_ceiling);
+    // MF2: In chat/code modes, request the 27B tier (subject to plan ceiling + RAM).
+    // mode:"code" implies quality → start higher in the cascade.
+    const mode = args.mode ?? "route";
+    const modeCeiling = (mode === "chat" || mode === "code") ? (args.model_ceiling ?? "27b") : args.model_ceiling;
+    const effectiveCeiling = clampCeiling(modeCeiling, ent.model_ceiling);
     // Clamp max_tokens to plan limit
     const maxTokens = Math.min(args.max_tokens ?? 1024, ent.max_tokens, 8192);
     // Cloud fallback only for paid plans
@@ -326,16 +354,16 @@ export async function runInfer(args, deps) {
     // Walk the tier table top → bottom, capped by model_ceiling. Each tier
     // logs its skip reason ("not_pulled" / "ram_insufficient" / fail reason)
     // so the caller can see exactly why each tier was bypassed.
+    let localDraft = null;
     if (installed) {
-        // Find start index from ceiling — if no ceiling, start at the top (32B).
         const ceilStart = effectiveCeiling
             ? Math.max(0, MODEL_TIERS.findIndex(t => t.tag.endsWith(`:${effectiveCeiling}`)))
             : 0;
         let anyViable = false;
         for (let i = ceilStart; i < MODEL_TIERS.length; i++) {
             const tier = MODEL_TIERS[i];
-            // Accept the tier whether Ollama reports it as bare (`prism-coder:32b`)
-            // or namespaced (`dcostenco/prism-coder:32b`, the form `ollama pull`
+            // Accept the tier whether Ollama reports it as bare (`prism-coder:27b`)
+            // 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 = resolveOllamaName(tier.tag, installed);
@@ -352,9 +380,27 @@ export async function runInfer(args, deps) {
             }
             anyViable = true;
             const timeout = args.timeout_ms ?? DEFAULT_TIMEOUTS[tier.tag] ?? 60_000;
-            const result = await deps.callLocal(deps.ollamaUrl, ollamaName, args.prompt, args.system, maxTokens, temperature, timeout);
+            const enableThink = args.think ?? (mode !== "route");
+            const result = await deps.callLocal(deps.ollamaUrl, ollamaName, args.prompt, args.system, maxTokens, temperature, timeout, enableThink);
             if (result.ok) {
-                return await applyVerification(result.text, gatedArgs, deps, {
+                const { stripped, thinkOnly } = stripThink(result.text);
+                const output = stripped;
+                // Quality gate for chat/code modes
+                if (mode !== "route") {
+                    const gate = passesQualityGate(output, thinkOnly, result.doneReason);
+                    if (!gate.pass && allowCloud) {
+                        debugLog(`[prism_infer] quality gate FAIL (${gate.reason}) — escalating to cloud`);
+                        attempts.push({ tier: tier.tag, reason: `quality_gate:${gate.reason}` });
+                        if (gate.reason === "hard_truncation" || gate.reason === "loop_detected") {
+                            localDraft = { output, tier: tier.tag };
+                        }
+                        break;
+                    }
+                    if (!gate.pass) {
+                        debugLog(`[prism_infer] quality gate FAIL (${gate.reason}) — no cloud, serving local`);
+                    }
+                }
+                return await applyVerification(output, gatedArgs, deps, {
                     backend: `ollama-${tier.tag.replace("prism-coder:", "")}`,
                     model_picked: tier.tag,
                     ram_free_mb: ramFreeMb,
@@ -392,7 +438,20 @@ export async function runInfer(args, deps) {
     else {
         attempts.push({ tier: "synalux", reason: "cloud_fallback_disabled" });
     }
-    // Everything failed.
+    // Cloud also failed — serve the local draft if we have one
+    if (localDraft) {
+        debugLog(`[prism_infer] cloud failed, serving gate-failed local draft from ${localDraft.tier}`);
+        return await applyVerification(localDraft.output, gatedArgs, deps, {
+            backend: `ollama-${localDraft.tier.replace("prism-coder:", "")}`,
+            model_picked: localDraft.tier,
+            ram_free_mb: ramFreeMb,
+            latency_ms: Date.now() - t0,
+            used_cloud: false,
+            attempts,
+            plan: ent.plan,
+            quality_gate_failed: true,
+        });
+    }
     const err = new Error(`prism_infer: no backend produced output. attempts=${JSON.stringify(attempts)}, free=${fmtGb(freeBytes)}`);
     err.attempts = attempts;
     throw err;
@@ -450,6 +509,7 @@ export async function prismInferHandler(args) {
             ` free_ram=${result.ram_free_mb}MB` +
             ` latency=${result.latency_ms}ms` +
             ` used_cloud=${result.used_cloud}` +
+            (result.quality_gate_failed ? ` quality_gate_failed=true` : "") +
             (result.verification ? ` verify=${result.verification.action}` : "") +
             (result.attempts.length ? ` attempts=${JSON.stringify(result.attempts)}` : "");
         return {

package/dist/utils/entitlements.js

@@ -32,7 +32,7 @@ const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 let cache = null;
 let inFlight = null;
 // ── Model tier ordering for ceiling enforcement ───────────────────
-const TIER_ORDER = ["2b", "4b", "9b", "32b"];
+const TIER_ORDER = ["2b", "4b", "9b", "27b"];
 /**
  * Returns true if `requested` exceeds `ceiling`.
  * e.g. ceilingExceeded("9b", "4b") → true (9b > 4b ceiling)

package/dist/utils/modelPicker.js

@@ -1,19 +1,19 @@
 /**
  * RAM-Gated Local Model Picker
  * ─────────────────────────────────────────────────────────────
- * Cascade: 9b (default) → 4b (verifier) → 2b (mobile) → 32b (complex only).
+ * Cascade: 9b (default) → 4b (verifier) → 2b (mobile) → 27b (quality).
  *
- * The default ceiling is "9b" — NOT "32b". This means:
+ * The default ceiling is "9b" — NOT "27b". This means:
  *   - 9b is the primary model for routing + general inference (Qwen3.5-9B, 100% BFCL)
  *   - 4b is used as the grounding verifier (fast, small)
  *   - 2b is the mobile/iPhone first gate (Qwen3.5-2B, 99.1% BFCL)
- *   - 32b is only loaded when caller explicitly passes ceiling="32b"
+ *   - 27b is only loaded when caller explicitly passes ceiling="27b"
  *     or when the task requires maximum quality (complex code gen, etc.)
  *
- * This saves 13GB+ RAM vs 32b and keeps response times fast.
+ * This saves 11GB+ RAM vs 27b and keeps response times fast.
  *
  *   tag                 weights   need free   ctx     role
- *   prism-coder:32b     ~19 GB    ≥ 24 GB     32K    complex (on-demand)
+ *   prism-coder:27b     ~16 GB    ≥ 20 GB     32K    quality (on-demand, Qwen3.5 DeltaNet, 100% BFCL)
  *   prism-coder:9b      ~ 5.8 GB  ≥  8 GB     32K    default router (Qwen3.5, 100% BFCL)
  *   prism-coder:4b      ~ 3.4 GB  ≥  5 GB     32K    verifier (Qwen3.5, 100%)
  *   prism-coder:2b      ~ 2.3 GB  ≥  3 GB      8K    mobile / iPhone (Qwen3.5, 99.1%)
@@ -26,30 +26,30 @@ const GB = 1024 ** 3;
  * the first row whose minFreeGb fits within freeBytes.
  */
 export const MODEL_TIERS = [
-    { tag: 'prism-coder:32b', weightsGb: 19, minFreeGb: 24, ctxTokens: 32_768 },
+    { tag: 'prism-coder:27b', weightsGb: 16, minFreeGb: 20, ctxTokens: 32_768 },
     { tag: 'prism-coder:9b', weightsGb: 5.8, minFreeGb: 8, ctxTokens: 32_768 },
     { tag: 'prism-coder:4b', weightsGb: 3.4, minFreeGb: 5, ctxTokens: 32_768 },
     { tag: 'prism-coder:2b', weightsGb: 2.3, minFreeGb: 3, ctxTokens: 8_192 },
 ];
 /**
  * True when `installed` matches `tierTag` either as a bare tag
- * (`prism-coder:32b`) or as a namespaced HuggingFace-style tag
- * (`dcostenco/prism-coder:32b`). The README documents `ollama pull
- * dcostenco/prism-coder:32b`, so Ollama's /api/tags returns the
+ * (`prism-coder:27b`) or as a namespaced HuggingFace-style tag
+ * (`dcostenco/prism-coder:27b`). The README documents `ollama pull
+ * dcostenco/prism-coder:27b`, so Ollama's /api/tags returns the
  * namespaced form — without this matcher the picker would never
  * see them and silently fall through to cloud.
  */
 function tagMatches(installed, tierTag) {
     return installed === tierTag || installed.endsWith(`/${tierTag}`);
 }
-/** Default ceiling: 9b. Pass ceiling="32b" explicitly for max quality. */
+/** Default ceiling: 9b. Pass ceiling="27b" explicitly for max quality. */
 export const DEFAULT_CEILING = "9b";
 /**
  * Pick the best viable tier for the given free RAM.
- * Default ceiling is 9b — use ceiling="32b" only for complex tasks.
+ * Default ceiling is 9b — use ceiling="27b" only for complex tasks.
  *
  * @param freeBytes  Result of os.freemem() — binary bytes
- * @param ceiling    Cap tier. Default "9b". Pass "32b" for complex tasks.
+ * @param ceiling    Cap tier. Default "9b". Pass "27b" for complex tasks.
  * @param available  Optional whitelist of installed Ollama tags.
  */
 export function pickLocalModel(freeBytes, ceiling, available) {
@@ -79,7 +79,7 @@ export function pickLocalModel(freeBytes, ceiling, available) {
 }
 /**
  * Resolve a tier tag to the actual Ollama name installed locally.
- * If `installed` contains a namespaced match (e.g. `dcostenco/prism-coder:32b`),
+ * If `installed` contains a namespaced match (e.g. `dcostenco/prism-coder:27b`),
  * the namespaced form is returned so Ollama's /api/generate finds it.
  * Falls back to the bare tag when only the bare form is present.
  */

package/dist/utils/qualityGate.js

@@ -0,0 +1,43 @@
+/**
+ * Quality Gate — deterministic check for obvious inference failures.
+ *
+ * NARROW by design: only high-precision signals that rarely false-positive.
+ * Does NOT judge correctness — that's the grounding verifier's job.
+ * Does NOT use refusal regex (too many false positives on legitimate output).
+ *
+ * Returns: { pass: boolean, reason?: string }
+ */
+/**
+ * Check if a model response passes the quality gate.
+ * @param stripped  Response AFTER think-stripping (use stripThink first)
+ * @param thinkOnly  True if the response was only <think> blocks with no answer
+ * @param finishReason  Ollama's finish_reason if available (e.g. "length" = truncated)
+ */
+export function passesQualityGate(stripped, thinkOnly, finishReason) {
+    // Signal 1: Think-only — model reasoned but produced no answer (check before empty)
+    if (thinkOnly) {
+        return { pass: false, reason: "think_only" };
+    }
+    // Signal 2: Empty or near-empty after stripping
+    if (stripped.trim().length < 5) {
+        return { pass: false, reason: "empty_response" };
+    }
+    // Signal 3: Hard truncation — Ollama reports finish_reason="length"
+    // meaning the model hit num_predict before finishing
+    if (finishReason === "length") {
+        return { pass: false, reason: "hard_truncation" };
+    }
+    // Signal 4: Exact-loop — same sentence repeated 3+ times
+    const sentences = stripped.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
+    if (sentences.length >= 6) {
+        const counts = new Map();
+        for (const s of sentences) {
+            const key = s.toLowerCase();
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+            if ((counts.get(key) ?? 0) >= 3) {
+                return { pass: false, reason: "loop_detected" };
+            }
+        }
+    }
+    return { pass: true };
+}

package/dist/utils/thinkStrip.js

@@ -0,0 +1,26 @@
+/**
+ * Think-Strip — remove <think>...</think> blocks from model output.
+ *
+ * Qwen3.5 uses <think> blocks for chain-of-thought reasoning.
+ * These must be stripped before serving to the user or passing
+ * to the grounding verifier (which would try to ground reasoning text).
+ *
+ * Returns: { stripped: string, thinkContent: string | null, thinkOnly: boolean }
+ */
+const THINK_RE = /<(?:think|\|synalux_think\|)>[\s\S]*?<\/(?:think|\|synalux_think\|)>\s*/g;
+const UNCLOSED_THINK_RE = /<(?:think|\|synalux_think\|)>[\s\S]*$/;
+export function stripThink(raw) {
+    if (!raw.includes("<think>") && !raw.includes("<|synalux_think|>")) {
+        return { stripped: raw, thinkContent: null, thinkOnly: false };
+    }
+    const thinkMatch = raw.match(/<(?:think|\|synalux_think\|)>([\s\S]*?)<\/(?:think|\|synalux_think\|)>/);
+    const thinkContent = thinkMatch ? thinkMatch[1].trim() : null;
+    let stripped = raw.replace(THINK_RE, "");
+    stripped = stripped.replace(UNCLOSED_THINK_RE, "");
+    stripped = stripped.trim();
+    return {
+        stripped,
+        thinkContent,
+        thinkOnly: stripped.length === 0 && raw.trim().length > 0,
+    };
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "prism-mcp-server",
-  "version": "19.0.1",
+  "version": "19.1.0",
   "mcpName": "io.github.dcostenco/prism-coder",
-  "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
+  "description": "Prism Coder \u2014 Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B\u201332B open-weights LLM fleet.",
   "module": "index.ts",
   "type": "module",
   "main": "dist/server.js",