prism-mcp-server 19.0.1 → 19.2.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.
@@ -78,6 +78,23 @@ Every session is logged with files changed, decisions made, and TODOs. Search, f
   <img src="docs/session-ledger.jpg" alt="Session Ledger — 93 sessions, 847 decisions logged across 12 projects" width="700" />
 </p>
 
+### Inference Metrics — see where your tokens go
+
+Every `prism_infer` call tracks which model handled it (local Ollama vs cloud) and how many tokens were consumed. When you save a session, Prism shows a summary:
+
+```
+📊 Inference Metrics (this session):
+  Total calls: 12 — Local: 10 (83%) | Cloud: 2 (17%)
+  Tokens: 8,420 in + 3,150 out = 11,570 total
+  Avg latency: 1,240ms
+  By model:
+    prism-coder:27b: 6 calls, 7,200 tokens, avg 1,800ms
+    prism-coder:9b: 4 calls, 2,870 tokens, avg 620ms
+    synalux-27b: 2 calls, 1,500 tokens, avg 1,100ms
+```
+
+Local calls use actual Ollama token counts; cloud calls use estimates. Metrics are aggregated by the Synalux portal — Prism is a thin client that forwards per-call data and fetches the summary on demand.
+
 ### Session Drift Detection
 
 Long agent sessions can wander from their original goal. `session_detect_drift` compares current work against the stated goal and returns `on_track / minor_drift / major_drift` so the agent can self-correct.
@@ -145,14 +162,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 +181,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 +208,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,11 +216,96 @@ 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.
 
+### Code Generation Quality (27B vs Claude Opus)
+
+Three progressively harder Python tasks run through `prism_infer(mode:"code", think:true)` on the local 27B and compared with Claude Opus. Both produce correct, production-quality code. The 27B is slightly more verbose (docstrings, examples); Opus is slightly tighter (`__slots__`, early-exit DFS). On routine coding the 27B at $0 replaces cloud calls entirely.
+
+| Task | Local 27B | Claude Opus | Verdict |
+|------|-----------|-------------|---------|
+| Fibonacci with memoization | `@lru_cache`, ValueError on negative, docstring | Nested `_fib` to keep cache private | Both correct, equivalent |
+| LRU Cache (OrderedDict, O(1)) | `Any` keys, isinstance capacity check, `__repr__` | `Hashable` key type (more precise), same ops | Both correct, Opus marginally tighter |
+| Trie with autocomplete | `.lower()` normalization, collect+sort+slice | `__slots__` on TrieNode, early-exit DFS at limit | Both correct, Opus slightly more optimized |
+
+<details>
+<summary>Local 27B output — Trie with autocomplete (hardest task)</summary>
+
+```python
+class TrieNode:
+    def __init__(self):
+        self.children: dict[str, 'TrieNode'] = {}
+        self.is_end_of_word: bool = False
+
+class Trie:
+    def __init__(self):
+        self.root: TrieNode = TrieNode()
+
+    def insert(self, word: str) -> None:
+        node = self.root
+        for char in word.lower():
+            if char not in node.children:
+                node.children[char] = TrieNode()
+            node = node.children[char]
+        node.is_end_of_word = True
+
+    def search(self, word: str) -> bool:
+        node = self._get_node(word.lower())
+        return node is not None and node.is_end_of_word
+
+    def starts_with(self, prefix: str) -> bool:
+        return self._get_node(prefix.lower()) is not None
+
+    def autocomplete(self, prefix: str, limit: int = 5) -> list[str]:
+        node = self._get_node(prefix.lower())
+        if node is None:
+            return []
+        results: list[str] = []
+        self._collect_words(node, prefix.lower(), results)
+        results.sort()
+        return results[:limit]
+
+    def _get_node(self, key: str) -> 'TrieNode | None':
+        node = self.root
+        for char in key:
+            if char not in node.children:
+                return None
+            node = node.children[char]
+        return node
+
+    def _collect_words(self, node: TrieNode, prefix: str, results: list[str]) -> None:
+        if node.is_end_of_word:
+            results.append(prefix)
+        for char, child in sorted(node.children.items()):
+            self._collect_words(child, prefix + char, results)
+```
+
+</details>
+
+| Metric | Local 27B | Cloud (Opus) |
+|--------|-----------|-------------|
+| Latency (Trie task) | ~30s | ~8s |
+| Cost | $0 | ~$0.05 |
+| Think mode | Enabled (stripped before serving) | N/A |
+| Quality gate | Passed (no escalation needed) | N/A |
+
+### Cloud Escalation in Practice (`cloud_fallback: true`)
+
+The same three tasks with `cloud_fallback: true` — the quality gate decides whether local output is good enough or needs cloud escalation.
+
+| Task | used_cloud | Quality Gate | Latency | What happened |
+|------|:----------:|-------------|---------|---------------|
+| Fibonacci (simple) | **no** | Passed | 11s | 27B served directly, $0 |
+| LRU Cache (medium) | **no** | Passed | 21s | 27B served directly, $0 |
+| Trie (hard) | **yes** | `loop_detected` | 55s | 27B looped → gate caught it → escalated to cloud 27B |
+
+The quality gate detected repeated sentences (≥3 of the same sentence in ≥6 total) in the 27B's Trie output and escalated automatically. The cloud fallback returned clean code. On a second run of the same prompt, the 27B produced clean output without escalation — the loop is stochastic, not systematic.
+
+**Takeaway:** for ~80–90% of coding tasks, the 27B handles everything locally at $0. The quality gate + cloud escalation exists as a safety net for the remaining cases where the local model loops, truncates, or produces empty output. Paid tiers get automatic escalation; free tier gets the local result with a warning.
+
 ---
 
 ## Why Prism Coder
@@ -254,7 +358,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 +388,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/config.js

@@ -307,11 +307,11 @@ const rawTiebreakerEpsilon = parseFloat(process.env.PRISM_TURBOQUANT_TIEBREAKER_
 export const PRISM_TURBOQUANT_TIEBREAKER_EPSILON = Number.isFinite(rawTiebreakerEpsilon) && rawTiebreakerEpsilon >= 0
     ? rawTiebreakerEpsilon
     : 0;
-// ─── v9.x: Local LLM (prism-coder:7b) Integration ─────────────────────────
+// ─── v9.x: Local LLM (prism-coder) Integration ────────────────────────────
 // Enables background tasks (compaction, task-router fallback, pipeline ops)
 // to use a local Ollama model instead of the cloud LLM provider.
 //
-// Default model is prism-coder:7b — fine-tuned on Prism tool schemas.
+// Default model is prism-coder:9b — fine-tuned on Prism tool schemas.
 // Disabled by default so existing deployments are unaffected.
 //
 // Set PRISM_LOCAL_LLM_ENABLED=true to activate.
@@ -319,10 +319,10 @@ export const PRISM_TURBOQUANT_TIEBREAKER_EPSILON = Number.isFinite(rawTiebreaker
 // Set PRISM_LOCAL_LLM_URL to override the Ollama endpoint (default: localhost: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:7b LLM for background tasks. */
+/** 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:7b").trim();
+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();
 /** Per-call timeout in ms. Prevents stalled background tasks. Capped at 300s. */

package/dist/tools/compactionHandler.js

@@ -108,7 +108,7 @@ function parseCompactionResponse(response, source) {
 }
 async function summarizeEntries(entries) {
     const prompt = buildCompactionPrompt(entries);
-    // ── Path 1: Local LLM (prism-coder:7b) ───────────────────────────
+    // ── Path 1: Local LLM (prism-coder:9b) ───────────────────────────
     if (PRISM_LOCAL_LLM_ENABLED) {
         debugLog(`[compact_ledger] Attempting local LLM summarization (${entries.length} entries)`);
         const localResponse = await callLocalLlm(prompt);
@@ -123,7 +123,7 @@ async function summarizeEntries(entries) {
         if (PRISM_STRICT_LOCAL_MODE) {
             throw new Error("[HIPAA] Local LLM failed and PRISM_STRICT_LOCAL_MODE=true. " +
                 "Cloud fallback is blocked to prevent unauthorized PHI disclosure. " +
-                "Ensure Ollama is running and prism-coder:7b is available.");
+                "Ensure Ollama is running and prism-coder:9b is available.");
         }
         debugLog(`[compact_ledger] Local LLM returned null — falling back to cloud LLM`);
     }

package/dist/tools/ledgerHandlers.js

@@ -89,6 +89,7 @@ const MEMORY_BOUNDARY_SUFFIX = '\n</prism_memory>';
  * After saving, generates an embedding vector for the entry via fire-and-forget.
  */
 import { computeEffectiveImportance, recordMemoryAccess } from "../utils/cognitiveMemory.js";
+import { fetchPortalInferenceMetrics, markSessionStart } from "../utils/inferenceMetrics.js";
 export async function sessionSaveLedgerHandler(args) {
     if (!isSessionSaveLedgerArgs(args)) {
         throw new Error("Invalid arguments for session_save_ledger");
@@ -229,6 +230,8 @@ export async function sessionSaveLedgerHandler(args) {
     storage.decayImportance(project, PRISM_USER_ID, 30).catch((err) => {
         debugLog(`[session_save_ledger] Background decay failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
     });
+    // Fetch inference metrics from portal (thin-client: portal is authority)
+    const metricsBlock = await fetchPortalInferenceMetrics();
     return {
         content: [{
                 type: "text",
@@ -238,6 +241,7 @@ export async function sessionSaveLedgerHandler(args) {
                     (files_changed?.length ? `Files changed: ${files_changed.length}\n` : "") +
                     (decisions?.length ? `Decisions: ${decisions.length}\n` : "") +
                     `📊 Embedding generation queued for semantic search.` +
+                    metricsBlock +
                     resolverNote,
             }],
         isError: false,
@@ -548,11 +552,13 @@ export async function sessionSaveHandoffHandler(args, server) {
         // Dynamic import itself failed — module not found or similar
         console.error("[FactMerger] Module load failed (non-fatal): " + err));
     }
+    const metricsBlock = await fetchPortalInferenceMetrics();
     // Build response text based on whether a CRDT merge occurred
     const responseText = isMerged
         ? `🔄 Auto-merged conflict for "${project}" (v${expected_version} → v${newVersion})\n` +
             `Strategy: ${JSON.stringify(mergeStrategy)}\n` +
             (last_summary ? `Summary: ${last_summary}\n` : "") +
+            metricsBlock +
             `\n🔑 Remember: pass expected_version: ${newVersion} on your next save ` +
             `to maintain concurrency control.`
         : `✅ Handoff ${data.status || "saved"} for project "${project}" ` +
@@ -561,6 +567,7 @@ export async function sessionSaveHandoffHandler(args, server) {
             (open_todos?.length ? `Open TODOs: ${open_todos.length} items\n` : "") +
             (active_branch ? `Active branch: ${active_branch}\n` : "") +
             `📊 Embedding generation queued for semantic search.\n` +
+            metricsBlock +
             `\n🔑 Remember: pass expected_version: ${newVersion} on your next save ` +
             `to maintain concurrency control.`;
     return {
@@ -575,6 +582,8 @@ export async function sessionLoadContextHandler(args) {
     if (!isSessionLoadContextArgs(args)) {
         throw new Error("Invalid arguments for session_load_context");
     }
+    // Mark session boundary — portal metrics fetched with since=this timestamp
+    markSessionStart();
     const { project, level = "standard", role } = args;
     const maxTokens = args.max_tokens
         || parseInt(await getSetting("max_tokens", "0"), 10) || undefined; // v4.0: arg > dashboard setting > none

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/4B/2B) 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,16 @@ 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";
+import { checkInputSafety, checkOutputSafety } from "../utils/safetyGate.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 / 4B / 2B — 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 +62,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 +72,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, 2B=15s.",
             },
             evidence: {
                 type: "array",
@@ -102,6 +105,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 +140,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 +168,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 +215,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 +240,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, promptTokens: data.prompt_eval_count, completionTokens: data.eval_count };
     }
     catch (err) {
         const name = err instanceof Error ? err.name : "Unknown";
@@ -275,12 +301,28 @@ async function callSynaluxInference(prompt, maxTokens, timeoutMs) {
 export async function runInfer(args, deps) {
     const t0 = Date.now();
     const temperature = args.temperature ?? 0;
+    // ── L1 Safety — deterministic input interception ────────────
+    const safetyIntercept = checkInputSafety(args.prompt);
+    if (safetyIntercept) {
+        return {
+            output: safetyIntercept,
+            backend: "safety_gate",
+            model_picked: null,
+            ram_free_mb: Math.round(deps.freemem() / (1024 * 1024)),
+            latency_ms: Date.now() - t0,
+            used_cloud: false,
+            attempts: [{ tier: "l1_safety", reason: "crisis_or_medical_intercept" }],
+        };
+    }
     // ── Entitlement enforcement ──────────────────────────────────
     // 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 +368,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 +394,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, promptTokens: result.promptTokens, completionTokens: result.completionTokens };
+                        }
+                        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,
@@ -362,6 +422,8 @@ export async function runInfer(args, deps) {
                     used_cloud: false,
                     attempts,
                     plan: ent.plan,
+                    prompt_tokens: result.promptTokens,
+                    completion_tokens: result.completionTokens,
                 });
             }
             attempts.push({ tier: tier.tag, reason: result.reason });
@@ -385,6 +447,8 @@ export async function runInfer(args, deps) {
                 used_cloud: true,
                 attempts,
                 plan: ent.plan,
+                prompt_tokens: Math.ceil(args.prompt.length / 4),
+                completion_tokens: Math.ceil(cloud.output.length / 4),
             });
         }
         attempts.push({ tier: "synalux", reason: cloud.reason ?? "unknown" });
@@ -392,7 +456,22 @@ 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,
+            prompt_tokens: localDraft.promptTokens,
+            completion_tokens: localDraft.completionTokens,
+            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;
@@ -405,9 +484,11 @@ export async function runInfer(args, deps) {
  * field so callers can route refusals separately from successes.
  */
 async function applyVerification(draft, args, deps, partial) {
+    // L1 output safety — intercept dangerous model-generated content
+    const safeDraft = checkOutputSafety(draft);
     const shouldVerify = args.verify ?? (args.evidence !== undefined && args.evidence.length > 0);
     if (!shouldVerify || !deps.callVerifier) {
-        return { ...partial, output: draft };
+        return { ...partial, output: safeDraft };
     }
     const verifier = deps.callVerifier;
     const outcome = await verifier({
@@ -419,7 +500,7 @@ async function applyVerification(draft, args, deps, partial) {
     });
     return {
         ...partial,
-        output: outcome.finalText,
+        output: checkOutputSafety(outcome.finalText),
         verification: {
             action: outcome.action,
             verifierChain: outcome.verifierChain,
@@ -444,12 +525,29 @@ export async function prismInferHandler(args) {
             ollamaUrl: PRISM_LOCAL_LLM_URL,
         });
         debugLog(`[prism_infer] backend=${result.backend} model=${result.model_picked} latency=${result.latency_ms}ms free=${result.ram_free_mb}MB`);
+        // Forward per-call metrics to portal (thin-client pattern).
+        // safety_gate excluded — logging crisis filter triggers is a HIPAA concern.
+        if (result.backend !== "safety_gate") {
+            ddLog("info", "prism_infer.usage", {
+                backend: result.backend,
+                model: result.model_picked ?? result.backend,
+                used_cloud: result.used_cloud,
+                prompt_tokens: result.prompt_tokens ?? 0,
+                completion_tokens: result.completion_tokens ?? 0,
+                latency_ms: result.latency_ms,
+            });
+        }
+        const tokenStr = result.prompt_tokens != null || result.completion_tokens != null
+            ? ` tokens=${result.prompt_tokens ?? "?"}in/${result.completion_tokens ?? "?"}out`
+            : "";
         const header = `[prism_infer] backend=${result.backend}` +
             ` model=${result.model_picked ?? "n/a"}` +
             ` plan=${result.plan ?? "unknown"}` +
             ` free_ram=${result.ram_free_mb}MB` +
             ` latency=${result.latency_ms}ms` +
             ` used_cloud=${result.used_cloud}` +
+            tokenStr +
+            (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/tools/taskRouterHandler.js

@@ -317,7 +317,7 @@ export async function sessionTaskRouteHandler(args) {
     delete result._rawComposite;
     // ── v9.x: Local LLM second-opinion for low-confidence cases ──────────────
     // When confidence is below the threshold AND local LLM is enabled,
-    // ask prism-coder:7b to break the tie. This is purely additive — if the
+    // ask prism-coder:9b to break the tie. This is purely additive — if the
     // LLM call fails or times out, the original heuristic result is returned.
     if (PRISM_LOCAL_LLM_ENABLED &&
         result.confidence < PRISM_TASK_ROUTER_CONFIDENCE_THRESHOLD) {
@@ -350,7 +350,7 @@ export async function sessionTaskRouteHandler(args) {
 }
 // ─── Local LLM Route Classifier ──────────────────────────────
 /**
- * Ask prism-coder:7b to classify a task description as "claw" or "host".
+ * Ask prism-coder:9b to classify a task description as "claw" or "host".
  * Returns the string or null if the model is unavailable / response unparseable.
  * Called only when heuristic confidence is below the threshold.
  */

package/dist/utils/ddLogger.js

@@ -8,9 +8,17 @@
  * Env: PRISM_SYNALUX_BASE_URL (default https://synalux.ai)
  */
 const SYNALUX_BASE = process.env.PRISM_SYNALUX_BASE_URL || "https://synalux.ai";
+const TELEMETRY_WRITE_TOKEN = process.env.TELEMETRY_WRITE_TOKEN || "";
 const DD_API_KEY = process.env.DD_API_KEY || "";
 const DD_SITE = process.env.DD_SITE || "datadoghq.com";
 const SERVICE = "prism-mcp";
+const CONTEXT_ALLOWLIST = new Set([
+    "backend", "model", "used_cloud", "prompt_tokens", "completion_tokens",
+    "latency_ms", "plan", "requested_ceiling", "effective_ceiling",
+    "ceiling_clamped", "requested_tokens", "effective_tokens", "tokens_clamped",
+    "cloud_requested", "cloud_allowed", "cloud_blocked",
+    "verify_requested", "verify_allowed", "verify_blocked",
+]);
 const queue = [];
 let flushTimer = null;
 const FLUSH_INTERVAL_MS = 5_000;
@@ -26,31 +34,61 @@ async function flush() {
         return;
     const batch = queue.splice(0, MAX_BATCH);
     // Primary: Synalux portal → Supabase (always available)
-    try {
-        await fetch(`${SYNALUX_BASE}/api/v1/telemetry`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(batch.map(e => ({
-                service: SERVICE,
-                event_type: e.status === "error" ? "error" : "action",
-                message: e.message,
-                context: { ...e, service: undefined, message: undefined },
-                user_id: e.user_id,
-                user_plan: e.user_plan,
-            }))),
-            signal: AbortSignal.timeout(5_000),
-        });
-    }
-    catch {
-        // Silent — don't crash the MCP server
+    if (TELEMETRY_WRITE_TOKEN) {
+        try {
+            await fetch(`${SYNALUX_BASE}/api/v1/telemetry`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${TELEMETRY_WRITE_TOKEN}`,
+                    "X-Prism-Client": "prism-mcp",
+                },
+                body: JSON.stringify(batch.map(e => {
+                    const ctx = {};
+                    for (const [k, v] of Object.entries(e)) {
+                        if (CONTEXT_ALLOWLIST.has(k))
+                            ctx[k] = v;
+                    }
+                    return {
+                        service: SERVICE,
+                        event_type: e.status === "error" ? "error" : "action",
+                        message: e.message,
+                        context: ctx,
+                        user_id: e.user_id,
+                        user_plan: e.user_plan,
+                    };
+                })),
+                signal: AbortSignal.timeout(5_000),
+            });
+        }
+        catch {
+            // Silent — don't crash the MCP server
+        }
     }
     // Secondary: Datadog Logs (if API key is set AND Logs product is enabled)
+    // Same allowlist applied — both sinks get identical filtered context.
     if (DD_API_KEY) {
         try {
             await fetch(`https://http-intake.logs.${DD_SITE}/api/v2/logs`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json", "DD-API-KEY": DD_API_KEY },
-                body: JSON.stringify(batch),
+                body: JSON.stringify(batch.map(e => {
+                    const ctx = {};
+                    for (const [k, v] of Object.entries(e)) {
+                        if (CONTEXT_ALLOWLIST.has(k))
+                            ctx[k] = v;
+                    }
+                    return {
+                        ddsource: "nodejs",
+                        ddtags: e.ddtags,
+                        hostname: e.hostname,
+                        service: SERVICE,
+                        status: e.status,
+                        message: e.message,
+                        ...ctx,
+                        timestamp: e.timestamp,
+                    };
+                })),
                 signal: AbortSignal.timeout(5_000),
             });
         }
@@ -68,7 +106,7 @@ export function ddLog(level, message, context) {
         hostname: process.env.HOSTNAME || "prism-mcp",
         service: SERVICE,
         status: level,
-        message,
+        message: message.slice(0, 200),
         ...context,
         timestamp: new Date().toISOString(),
     });

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/inferenceMetrics.js

@@ -0,0 +1,64 @@
+/**
+ * Inference metrics — thin-client fetch from Synalux portal.
+ *
+ * Prism forwards per-call metrics via ddLog("prism_infer.usage").
+ * The portal aggregates them in app_telemetry. This module fetches
+ * the aggregated summary on demand (session_save_ledger/handoff).
+ */
+import { getSynaluxJwt } from "./synaluxJwt.js";
+import { PRISM_SYNALUX_BASE_URL } from "../config.js";
+import { debugLog } from "./logger.js";
+let sessionStartedAt = new Date().toISOString();
+export function markSessionStart() {
+    sessionStartedAt = new Date().toISOString();
+}
+async function fetchMetrics() {
+    if (!PRISM_SYNALUX_BASE_URL)
+        return { metrics: null, error: "no_portal_url" };
+    const jwt = await getSynaluxJwt();
+    if (!jwt)
+        return { metrics: null, error: "jwt_unavailable" };
+    try {
+        const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/telemetry/inference-metrics?since=${encodeURIComponent(sessionStartedAt)}`;
+        const res = await fetch(url, {
+            headers: { "Authorization": `Bearer ${jwt}` },
+            signal: AbortSignal.timeout(5_000),
+        });
+        if (!res.ok) {
+            debugLog(`[inference-metrics] portal returned ${res.status}`);
+            return { metrics: null, error: `portal_${res.status}` };
+        }
+        return { metrics: (await res.json()) };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        debugLog(`[inference-metrics] fetch failed: ${msg}`);
+        return { metrics: null, error: msg };
+    }
+}
+export async function fetchPortalInferenceMetrics() {
+    const { metrics, error } = await fetchMetrics();
+    if (!metrics) {
+        if (error)
+            debugLog(`[inference-metrics] unavailable: ${error}`);
+        return "";
+    }
+    if (metrics.total_calls === 0)
+        return "";
+    const lines = [
+        `\n📊 Inference Metrics (this session):`,
+        `  Total calls: ${metrics.total_calls} — Local: ${metrics.local_calls} (${metrics.local_pct}%) | Cloud: ${metrics.cloud_calls} (${metrics.cloud_pct}%)`,
+        `  Tokens: ${metrics.total_prompt_tokens.toLocaleString()} in + ${metrics.total_completion_tokens.toLocaleString()} out = ${metrics.total_tokens.toLocaleString()} total`,
+        `  Avg latency: ${metrics.avg_latency_ms}ms`,
+    ];
+    const models = Object.entries(metrics.by_model).sort((a, b) => b[1].calls - a[1].calls);
+    if (models.length > 1) {
+        lines.push(`  By model:`);
+        for (const [name, stats] of models) {
+            const tokens = stats.prompt_tokens + stats.completion_tokens;
+            const avgMs = stats.calls > 0 ? Math.round(stats.total_latency_ms / stats.calls) : 0;
+            lines.push(`    ${name}: ${stats.calls} calls, ${tokens.toLocaleString()} tokens, avg ${avgMs}ms`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/utils/localLlm.js

@@ -1,5 +1,5 @@
 /**
- * Local LLM Client — Ollama/prism-coder:7b Integration (v1.0.0)
+ * Local LLM Client — Ollama/prism-coder:9b Integration (v1.0.0)
  * ──────────────────────────────────────────────────────────────────
  * Thin HTTP wrapper around the Ollama /api/chat endpoint.
  *
@@ -9,7 +9,7 @@
  *   - Silent fail: returning null instead of throwing ensures callers
  *     can fall back to Gemini without crashing the MCP server.
  *   - Fire-and-forget safe: wrapped in try/catch, never propagates.
- *   - Default model: prism-coder:7b — fine-tuned on Prism tool schemas,
+ *   - Default model: prism-coder:9b — fine-tuned on Prism tool schemas,
  *     8192-token context, Q8_0 quantization, ~8.1GB RAM footprint.
  *
  * FEATURE FLAG:

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/nerExtractor.js

@@ -16,7 +16,7 @@
  *
  * Architecture:
  *   1. Rule-based extraction (fast, zero-cost, always available)
- *   2. Local LLM extraction (optional, higher quality, uses prism-coder:7b)
+ *   2. Local LLM extraction (optional, higher quality, uses prism-coder:9b)
  *   3. Merged + deduplicated results
  */
 import { debugLog } from "./logger.js";

package/dist/utils/qualityGate.js

@@ -0,0 +1,67 @@
+/**
+ * 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 detection (two passes).
+    //
+    // Pass A (prose-only, threshold ≥3): strip structural markdown that
+    // naturally repeats (code blocks, tables, headings, bold labels).
+    // Catches loops in explanatory text.
+    const proseOnly = stripped
+        .replace(/```[\s\S]*?```/g, "")
+        .replace(/^\|.*\|$/gm, "")
+        .replace(/^#{1,6}\s+.*$/gm, "")
+        .replace(/^[\s*-]*\*{1,2}[^*]+\*{1,2}:?\s*$/gm, "");
+    const proseSentences = proseOnly.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
+    if (proseSentences.length >= 6) {
+        const counts = new Map();
+        for (const s of proseSentences) {
+            const key = s.toLowerCase();
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+            if ((counts.get(key) ?? 0) >= 3) {
+                return { pass: false, reason: "loop_detected" };
+            }
+        }
+    }
+    // Pass B (full text, threshold ≥5): catches egregious loops hidden
+    // inside fake code blocks or other structural elements. Higher
+    // threshold avoids false positives on legitimate code patterns
+    // (e.g. `node = self.root` × 4 is fine, × 5 is suspicious).
+    const allSentences = stripped.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
+    if (allSentences.length >= 10) {
+        const counts = new Map();
+        for (const s of allSentences) {
+            const key = s.toLowerCase();
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+            if ((counts.get(key) ?? 0) >= 5) {
+                return { pass: false, reason: "loop_detected" };
+            }
+        }
+    }
+    return { pass: true };
+}

package/dist/utils/safetyGate.js

@@ -0,0 +1,104 @@
+/**
+ * L1 Safety Gate — deterministic crisis/medical interception for prism_infer.
+ *
+ * Runs BEFORE model output reaches the caller. High precision, low recall:
+ * only intercepts patterns that unambiguously indicate self-harm intent
+ * (input) or dangerous instructions (output). Generic clinical/pharmacological
+ * terms ("dose of", "milligrams", "lethal") are NOT intercepted — they appear
+ * in routine BCBA/medical notes.
+ *
+ * This is a backstop, not a comprehensive filter. The model's own safety
+ * training is the primary layer.
+ */
+// ── Input: first-person crisis expressions ───────────────────────────────────
+const CRISIS_INPUT_RE = [
+    // English
+    /hurt(?:ing)?\s+(?:my)?self/i,
+    /kill\s+(?:my)?self/i,
+    /end\s+my\s+life/i,
+    /want\s+to\s+die/i,
+    /want\s+to\s+(?:commit\s+)?suicide/i,
+    /cut(?:ting)?\s+(?:my)?self/i,
+    /(?:hang|hanging)\s+(?:my)?self/i,
+    /jump(?:ing)?\s+off/i,
+    /how\s+(?:many|much|to).*(?:pills|overdose|die)/i,
+    // Spanish — block hyperbole nouns only (NOT hunger/thirst/cold — may be literal for neglected child)
+    /quiero\s+morir(?!\s+de\s+(?:risa|la\s+risa|vergüenza|ganas|envidia|aburrimiento)\b)/i,
+    /(?:voy\s+a\s+)?matarme(?!\s+(?:estudiando|trabajando|riendo|de\s+(?:risa|la\s+risa))\b)/i,
+    /hacerme\s+da[ñn]o/i,
+    /(?:quiero\s+)?suicidarme/i,
+    // French — block hyperbole nouns only (NOT faim/soif/chaud/froid)
+    /je\s+veux\s+mourir(?!\s+d[e']\s*(?:rire|honte|envie|ennui)\b)/i,
+    /(?:vais\s+)?me\s+tuer(?!\s+[àa]\s+(?:rire|travailler|étudier)\b)/i,
+    /me\s+suicider/i,
+    // Portuguese — block hyperbole nouns only (NOT fome/sede/calor/frio/sono)
+    /quero\s+morrer(?!\s+de\s+(?:rir|vergonha|inveja|tédio)\b)/i,
+    /(?:vou\s+)?me\s+matar(?!\s+(?:estudando|trabalhando|rindo|de\s+(?:rir|tanto))\b)/i,
+    // Russian — block hyperbole nouns (смех/стыд/зависть/голод/жара/скука)
+    // Russian — NOT голода/жары/холода (may be literal)
+    /хочу\s+умереть(?!\s+от\s+(?:смеха|стыда|зависти|скуки)(?:\s|$))/i,
+    /убить\s+себя/i,
+    /покончить\s+с\s+собой/i,
+    // Arabic (alef variants handled in normalize)
+    /[اأإآ]ر[يى]د\s+[اأإآ]ن\s+[اأإآ]موت/,
+    /قتل\s+نفس[يى]/,
+    /[اأإآ]نه[يى]\s+ح[يى][اأإآ]ت[يى]/,
+    // German — block hyperbole nouns (Lachen/Scham/Neid/Hunger/Langeweile)
+    // German — NOT hunger/kälte (may be literal)
+    /(?:ich\s+)?will\s+sterben(?!\s+vor\s+(?:lachen|scham|neid|langeweile)\b)/i,
+    /mich\s+umbringen/i,
+    // Ukrainian — block hyperbole nouns (сміх/сором/заздрість/голод)
+    // Ukrainian — NOT голоду/холоду (may be literal)
+    /хочу\s+померти(?!\s+від\s+(?:сміху|сорому|заздрості|нудьги)(?:\s|$))/i,
+    /вбити\s+себе/i,
+];
+const MEDICAL_INPUT_RE = [
+    /(?:how\s+much|what\s+dose)\s+.*(?:should\s+I|do\s+I|can\s+I)\s+(?:inject|take|give)/i,
+    /(?:dose|dosage)\s+(?:should\s+I|do\s+I|can\s+I)\s+(?:inject|take|give)/i,
+];
+// ── Output: model providing dangerous instructions ───────────────────────────
+const CRISIS_OUTPUT_RE = [
+    /\bhow many pills\s+to\b/i,
+    /\boverdose amount\b/i,
+    /\bnoose\b/i,
+    /\bhanging yourself\b/i,
+    /\bsuicide method\b/i,
+    /\bmethod of suicide\b/i,
+    /\bself[- ]?harm method\b/i,
+    /\bhow to (?:kill|hang|poison|overdose)\s+(?:your|my|him|her|them|one)self\b/i,
+    /\bhow to overdose\b/i,
+];
+const MEDICAL_OUTPUT_RE = [
+    /\binject this (?:amount|dose|much)\b/i,
+    /\btake this (?:amount|many|dose)\b/i,
+    /\byou should (?:inject|take)\s+\d+\s+units\b/i,
+];
+// ── Responses ────────────────────────────────────────────────────────────────
+export const CRISIS_RESPONSE = "I'm concerned about your safety. Please call or text 988 (Suicide & Crisis Lifeline) right now — available 24/7. If in immediate danger, call 911. International: findahelpline.com. You are not alone.";
+export const MEDICAL_RESPONSE = "I cannot provide specific medical dosing advice. Please contact your doctor or pharmacist. For emergencies, call 911.";
+// ── API ──────────────────────────────────────────────────────────────────────
+function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/\p{Cf}/gu, "")
+        .replace(/\p{Mn}/gu, "") // Arabic harakat + all combining marks
+        .replace(/ـ/g, "")
+        .replace(/[أإآ]/g, "ا")
+        .replace(/\s+/g, " ");
+}
+export function checkInputSafety(text) {
+    const t = normalize(text);
+    if (CRISIS_INPUT_RE.some(p => p.test(t)))
+        return CRISIS_RESPONSE;
+    if (MEDICAL_INPUT_RE.some(p => p.test(t)))
+        return MEDICAL_RESPONSE;
+    return null;
+}
+export function checkOutputSafety(response) {
+    const r = normalize(response);
+    if (CRISIS_OUTPUT_RE.some(re => re.test(r)))
+        return CRISIS_RESPONSE;
+    if (MEDICAL_OUTPUT_RE.some(re => re.test(r)))
+        return MEDICAL_RESPONSE;
+    return response;
+}

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,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "19.0.1",
+  "version": "19.2.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.",
   "module": "index.ts",