prism-mcp-server 18.0.2 → 19.0.0

package/dist/server.js

@@ -66,6 +66,7 @@ import { startDarkFactoryRunner } from "./darkfactory/runner.js";
 import { getSyncBus } from "./sync/factory.js";
 import { startDashboardServer } from "./dashboard/server.js";
 import { acquireLock, registerShutdownHandlers } from "./lifecycle.js";
+import { verifyBehaviorHandler } from "./tools/behavioralVerifierHandler.js";
 // ─── v2.3.6 FIX: Use Storage Abstraction for Prompts/Resources ───
 // CRITICAL FIX: Previously imported supabaseRpc/supabaseGet directly,
 // which bypassed the storage abstraction layer and caused the server
@@ -106,6 +107,8 @@ SESSION_BACKFILL_LINKS_TOOL, SESSION_SYNTHESIZE_EDGES_TOOL, SESSION_COGNITIVE_RO
 SESSION_TASK_ROUTE_TOOL, 
 // Session Drift Detection
 SESSION_DETECT_DRIFT_TOOL, 
+// Behavioral Verifier
+VERIFY_BEHAVIOR_TOOL, isVerifyBehaviorArgs, 
 // v12: Developer Onboarding & Enterprise Observability
 ONBOARDING_WIZARD_TOOL, EXTRACT_ENTITIES_TOOL, API_ANALYTICS_TOOL, BACKUP_DATABASE_TOOL, CONFIGURE_NOTIFICATIONS_TOOL, QUERY_MEMORY_NATURAL_TOOL, 
 // v15.5: Knowledge Ingestion
@@ -230,6 +233,7 @@ function buildSessionMemoryTools(autoloadList) {
         SESSION_SYNTHESIZE_EDGES_TOOL, // session_synthesize_edges — inferred semantic graph enrichment
         SESSION_COGNITIVE_ROUTE_TOOL, // session_cognitive_route — HDC policy-gated concept routing (v6.5)
         SESSION_DETECT_DRIFT_TOOL, // session_detect_drift — semantic goal drift detection (synalux)
+        VERIFY_BEHAVIOR_TOOL, // verify_behavior — behavioral verification via Synalux portal
         // ─── v6.1: Storage Hygiene tool ───
         MAINTENANCE_VACUUM_TOOL, // maintenance_vacuum — reclaim SQLite disk space post-purge
         // ─── v12.1: Developer Onboarding & Framework Bridge ───
@@ -892,6 +896,11 @@ export function createServer() {
                             throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
                         result = await sessionDetectDriftHandler(args);
                         break;
+                    case "verify_behavior":
+                        if (!isVerifyBehaviorArgs(args))
+                            throw new Error("file_path and change_summary required.");
+                        result = await verifyBehaviorHandler(args);
+                        break;
                     // ─── v7.3: Dark Factory Pipeline Tools ───
                     case "session_start_pipeline":
                         if (!SESSION_MEMORY_ENABLED)

package/dist/tools/behavioralVerifierHandler.js

@@ -0,0 +1,80 @@
+/**
+ * Behavioral Verifier — thin client to Synalux portal API.
+ *
+ * Calls POST /api/v1/prism/verify-behavior with the file path
+ * and returns a domain-specific scenario the agent must answer
+ * before editing the file.
+ *
+ * FAIL-CLOSED: if the portal is unreachable, returns a generic
+ * verification challenge rather than skipping verification.
+ */
+import { PRISM_SYNALUX_BASE_URL, SYNALUX_CONFIGURED } from "../config.js";
+import { getSynaluxJwt } from "../utils/synaluxJwt.js";
+import { debugLog } from "../utils/logger.js";
+const FALLBACK_SCENARIO = [
+    "⚠️ BEHAVIORAL VERIFICATION (OFFLINE MODE)",
+    "",
+    "Portal unreachable — using generic verification.",
+    "Before editing this file, answer ALL of these:",
+    "",
+    "1. What does the end user experience BEFORE vs AFTER this change?",
+    "2. Does this endpoint verify the caller owns/belongs-to the resource?",
+    "3. Can a user from workspace A access workspace B's data by guessing an ID?",
+    "4. If this is a revert, was the original change actually correct?",
+    "",
+    "Answer concretely. If you cannot, READ THE FILE FIRST.",
+].join("\n");
+export async function verifyBehaviorHandler(args) {
+    if (!SYNALUX_CONFIGURED || !PRISM_SYNALUX_BASE_URL) {
+        return FALLBACK_SCENARIO;
+    }
+    const jwt = await getSynaluxJwt();
+    if (!jwt) {
+        debugLog("[verify-behavior] JWT unavailable — fail-closed with generic scenario");
+        return FALLBACK_SCENARIO;
+    }
+    try {
+        const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism/verify-behavior`;
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                file_path: args.file_path,
+                change_summary: args.change_summary,
+                workspace_id: args.workspace_id,
+            }),
+            signal: AbortSignal.timeout(5_000),
+        });
+        if (!res.ok) {
+            debugLog(`[verify-behavior] portal returned ${res.status} — fail-closed`);
+            return FALLBACK_SCENARIO;
+        }
+        const data = (await res.json());
+        return formatResult(data);
+    }
+    catch (err) {
+        debugLog(`[verify-behavior] error: ${err.message} — fail-closed`);
+        return FALLBACK_SCENARIO;
+    }
+}
+function formatResult(data) {
+    if (!data.requires_verification) {
+        return JSON.stringify({ requires_verification: false, reason: data.reason || "non-behavioral file" });
+    }
+    return [
+        `⚠️ BEHAVIORAL VERIFICATION REQUIRED`,
+        `Domain: ${data.domain}`,
+        ``,
+        `Before making this edit, answer this scenario:`,
+        ``,
+        data.scenario || "(generic) Describe what the end user experiences BEFORE vs AFTER this change.",
+        ``,
+        `RULES:`,
+        ...(data.rules || []).map((r, i) => `${i + 1}. ${r}`),
+        ``,
+        `Answer the scenario in your next message before proceeding with the edit.`,
+    ].join("\n");
+}

package/dist/tools/index.js

@@ -57,6 +57,8 @@ export { onboardingWizardHandler, extractEntitiesHandler, apiAnalyticsHandler, b
 // ── Session Drift Detection ──
 export { SESSION_DETECT_DRIFT_TOOL, isSessionDetectDriftArgs } from "./sessionMemoryDefinitions.js";
 export { sessionDetectDriftHandler } from "./sessionDriftHandler.js";
+export { VERIFY_BEHAVIOR_TOOL, isVerifyBehaviorArgs } from "./sessionMemoryDefinitions.js";
+export { verifyBehaviorHandler } from "./behavioralVerifierHandler.js";
 // ── Knowledge Ingestion (v15.5 — Open Interface) ──
 // Chunks source code, generates Q&A via Claude Haiku, stores in knowledge graph.
 // Three entry points: MCP tool, REST API, GitHub webhook.

package/dist/tools/ledgerHandlers.js

@@ -840,50 +840,47 @@ export async function sessionLoadContextHandler(args) {
         }
     }
     // ─── Project-Aware Skill Injection ──────────────────────────
-    // Routing (WHICH skills + user_local policy): Synalux /api/v1/skills/routing.
-    // Content (WHAT):
-    //   Platform skills  → Synalux /api/v1/skills/content (DB first, filesystem fallback)
-    //                      → local SQLite skill:<name> (free tier / offline fallback)
-    //   User-local skills → local SQLite user_skill:<name>
-    //                       ONLY when user_local.enabled=true in routing table
-    //                       OR session_load_context called with user_local=true.
-    //                       Users CANNOT write to the platform skill: namespace.
+    // Skills are priority-sorted and cap-aware. Protected skills always load
+    // (they bypass the cap check). This prevents the silent-truncation bug
+    // where important behavioral skills were dropped because large low-priority
+    // skills consumed the budget first.
     const { resolveSkillsForProject } = await import("./skillRouting.js");
     const resolved = await resolveSkillsForProject(project);
-    const skillsToLoad = resolved.names;
+    const sortedSkills = resolved.skills;
     const userLocalPolicy = resolved.user_local;
-    // Paid tier: batch-fetch platform skill content from Synalux in one request.
     let synaluxContent = {};
     if (SYNALUX_CONFIGURED && storage && typeof storage.fetchSkillContent === "function") {
-        const missing = skillsToLoad.filter(n => !loadedSkills.includes(n));
+        const missing = sortedSkills.map(s => s.name).filter(n => !loadedSkills.includes(n));
         synaluxContent = await storage
             .fetchSkillContent(missing).catch(() => ({}));
         debugLog(`[session_load_context] Synalux skill content fetched: ${Object.keys(synaluxContent).join(", ") || "none"}`);
     }
-    const SKILL_BLOCK_CAP = 30_000;
+    const SKILL_BLOCK_CAP = 40_000;
     const skippedSkills = [];
-    for (const skillName of skillsToLoad) {
-        if (loadedSkills.includes(skillName))
+    for (const entry of sortedSkills) {
+        if (loadedSkills.includes(entry.name))
             continue;
-        if (skillBlock.length >= SKILL_BLOCK_CAP) {
-            skippedSkills.push(skillName);
-            debugLog(`[session_load_context] Skill "${skillName}" skipped — block cap ${SKILL_BLOCK_CAP} reached`);
+        const content = synaluxContent[entry.name] || await getSetting(`skill:${entry.name}`, "");
+        if (!content || !content.trim())
             continue;
-        }
-        const content = synaluxContent[skillName] || await getSetting(`skill:${skillName}`, "");
-        if (content && content.trim()) {
-            const trimmed = content.trim();
-            if (skillBlock.length + trimmed.length > SKILL_BLOCK_CAP && loadedSkills.length > 0) {
-                skippedSkills.push(skillName);
-                debugLog(`[session_load_context] Skill "${skillName}" skipped — would exceed cap (${skillBlock.length}+${trimmed.length} > ${SKILL_BLOCK_CAP})`);
-                continue;
-            }
-            const source = synaluxContent[skillName] ? "synalux" : "local-platform";
-            skillBlock += `\n\n[📜 SKILL: ${skillName}]\n${trimmed}`;
-            loadedSkills.push(skillName);
+        const trimmed = content.trim();
+        if (entry.protected) {
+            skillBlock += `\n\n[📜 SKILL: ${entry.name}]\n${trimmed}`;
+            loadedSkills.push(entry.name);
             skillLoaded = true;
-            debugLog(`[session_load_context] Skill "${skillName}" loaded (${source}) for project="${project}" [${skillBlock.length}/${SKILL_BLOCK_CAP} chars]`);
+            debugLog(`[session_load_context] Skill "${entry.name}" loaded (protected, p${entry.priority}) [${skillBlock.length} chars]`);
+            continue;
+        }
+        if (skillBlock.length + trimmed.length > SKILL_BLOCK_CAP) {
+            skippedSkills.push(entry.name);
+            debugLog(`[session_load_context] Skill "${entry.name}" skipped — would exceed cap (${skillBlock.length}+${trimmed.length} > ${SKILL_BLOCK_CAP})`);
+            continue;
         }
+        const source = synaluxContent[entry.name] ? "synalux" : "local-platform";
+        skillBlock += `\n\n[📜 SKILL: ${entry.name}]\n${trimmed}`;
+        loadedSkills.push(entry.name);
+        skillLoaded = true;
+        debugLog(`[session_load_context] Skill "${entry.name}" loaded (${source}, p${entry.priority}) [${skillBlock.length}/${SKILL_BLOCK_CAP} chars]`);
     }
     // ─── User-Local Skills ──────────────────────────────────────
     // Loaded ONLY when user_local.enabled=true (set in Synalux routing table
@@ -936,7 +933,7 @@ export async function sessionLoadContextHandler(args) {
         }
     }
     if (skippedSkills.length > 0) {
-        skillBlock += `\n\n[⏭️ ${skippedSkills.length} skills skipped (cap ${SKILL_BLOCK_CAP} chars): ${skippedSkills.join(", ")}]`;
+        skillBlock += `\n\n[⚠️ ${skippedSkills.length} skills TRUNCATED by ${SKILL_BLOCK_CAP}-char cap — NOT loaded: ${skippedSkills.join(", ")}. These rules are NOT in your context. Do not claim to follow them.]`;
     }
     // ─── Agent Greeting Block ────────────────────────────────────
     // Shows agent identity (name + role) and skill status after briefing.

package/dist/tools/prismInferHandler.js

@@ -60,7 +60,7 @@ export const PRISM_INFER_TOOL = {
             },
             model_ceiling: {
                 type: "string",
-                enum: ["32b", "14b", "8b", "1b7"],
+                enum: ["32b", "14b", "4b", "2b"],
                 description: "Cap the largest tier the picker may select. e.g. '14b' forbids 32B even if RAM allows.",
             },
             cloud_fallback: {
@@ -70,7 +70,7 @@ export const PRISM_INFER_TOOL = {
             },
             timeout_ms: {
                 type: "number",
-                description: "Override per-call timeout. Default scales with model size: 32B=120s, 14B=60s, 8B=30s, 1.7B=15s.",
+                description: "Override per-call timeout. Default scales with model size: 32B=120s, 14B=60s, 4B=20s, 1.7B=15s.",
             },
             evidence: {
                 type: "array",
@@ -91,12 +91,12 @@ export const PRISM_INFER_TOOL = {
                 type: "boolean",
                 description: "Enable the L3 grounding verifier. Default: true when `evidence` is provided, " +
                     "false otherwise. When enabled, the model's draft is checked by a different model " +
-                    "(prism-coder:4b by default) against the supplied `evidence`. Drafts with " +
+                    "(qwen3.5:4b by default) against the supplied `evidence`. Drafts with " +
                     "NEUTRAL or CONTRADICTED claims are refused.",
             },
             verifier_model: {
                 type: "string",
-                description: "Override the verifier model. Default: prism-coder:4b.",
+                description: "Override the verifier model. Default: qwen3.5:4b.",
             },
             verifier_timeout_ms: {
                 type: "number",
@@ -124,7 +124,7 @@ export function isPrismInferArgs(args) {
     if (a.timeout_ms !== undefined && typeof a.timeout_ms !== "number")
         return false;
     if (a.model_ceiling !== undefined &&
-        !["32b", "14b", "8b", "1b7"].includes(a.model_ceiling))
+        !["32b", "14b", "4b", "2b"].includes(a.model_ceiling))
         return false;
     if (a.verify !== undefined && typeof a.verify !== "boolean")
         return false;
@@ -149,8 +149,8 @@ export function isPrismInferArgs(args) {
 const DEFAULT_TIMEOUTS = {
     "prism-coder:32b": 120_000,
     "prism-coder:14b": 60_000,
-    "prism-coder:8b": 30_000,
-    "prism-coder:1b7": 15_000,
+    "qwen3.5:4b": 20_000,
+    "prism-coder:2b": 15_000,
 };
 /** List Ollama-installed tags. Returns null if Ollama unreachable. */
 export async function listOllamaTags(url = PRISM_LOCAL_LLM_URL) {
@@ -330,7 +330,7 @@ export async function runInfer(args, deps) {
     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) || t.tag === 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++) {

package/dist/tools/sessionMemoryDefinitions.js

@@ -1750,3 +1750,43 @@ export function isSessionDetectDriftArgs(args) {
         return false;
     return true;
 }
+// ─── Behavioral Verifier ────────────────────────────────────────
+export const VERIFY_BEHAVIOR_TOOL = {
+    name: "verify_behavior",
+    description: "Call BEFORE editing behavioral source files (API routes, ordering logic, billing, auth, migrations). " +
+        "Returns a domain-specific scenario you must answer to demonstrate understanding of the end-user impact. " +
+        "Example: editing a KDS route returns 'A cook has a 3-item ticket. One item is voided. What should the cook see?' " +
+        "Answer the scenario concretely before proceeding with the edit.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            file_path: {
+                type: "string",
+                description: "Path of the file about to be edited.",
+            },
+            change_summary: {
+                type: "string",
+                description: "Brief description of the intended change.",
+            },
+            project: {
+                type: "string",
+                description: "Optional project identifier for workspace-scoped scenarios.",
+            },
+            workspace_id: {
+                type: "string",
+                description: "Optional workspace ID for custom scenarios.",
+            },
+        },
+        required: ["file_path", "change_summary"],
+    },
+};
+export function isVerifyBehaviorArgs(a) {
+    if (!a || typeof a !== "object")
+        return false;
+    const o = a;
+    if (typeof o.file_path !== "string" || !o.file_path.trim())
+        return false;
+    if (typeof o.change_summary !== "string")
+        return false;
+    return true;
+}

package/dist/tools/skillRouting.js

@@ -19,7 +19,11 @@
 // Minimal fallback when synalux is unreachable.
 const OFFLINE_FALLBACK = {
     version: 1,
-    universal: ['bcba_ai_assistant'],
+    universal: [
+        { name: 'prime-directive', priority: 0, protected: true },
+        { name: 'evidence-first-protocol', priority: 1, protected: true },
+        { name: 'bcba_ai_assistant', priority: 20 },
+    ],
     projects: {},
     user_local: { enabled: false, key_prefix: 'user_skill:' },
 };
@@ -56,6 +60,12 @@ async function fetchOnce() {
  * skills. Also returns the user_local policy so callers know whether to
  * load user_skill:* entries from local SQLite.
  */
+function normalizeEntry(entry, defaultPriority) {
+    if (typeof entry === 'string') {
+        return { name: entry, priority: defaultPriority, protected: false };
+    }
+    return { name: entry.name, priority: entry.priority ?? defaultPriority, protected: entry.protected ?? false };
+}
 export async function resolveSkillsForProject(project) {
     const now = Date.now();
     if (!cached || now - cached.fetchedAt > CACHE_TTL_MS) {
@@ -68,16 +78,31 @@ export async function resolveSkillsForProject(project) {
         await inflight;
     }
     const table = cached.table;
-    const out = new Set(table.universal);
+    const seen = new Set();
+    const skills = [];
+    for (let i = 0; i < table.universal.length; i++) {
+        const entry = normalizeEntry(table.universal[i], i);
+        if (!seen.has(entry.name)) {
+            seen.add(entry.name);
+            skills.push(entry);
+        }
+    }
     const projectLower = project.toLowerCase();
-    for (const [pattern, skills] of Object.entries(table.projects)) {
+    let projectPriority = 100;
+    for (const [pattern, projectSkills] of Object.entries(table.projects)) {
         if (projectLower.includes(pattern)) {
-            for (const s of skills)
-                out.add(s);
+            for (const s of projectSkills) {
+                if (!seen.has(s)) {
+                    seen.add(s);
+                    skills.push({ name: s, priority: projectPriority++, protected: false });
+                }
+            }
         }
     }
+    skills.sort((a, b) => a.priority - b.priority);
     return {
-        names: Array.from(out),
+        names: skills.map(s => s.name),
+        skills,
         user_local: table.user_local ?? OFFLINE_FALLBACK.user_local,
     };
 }

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 = ["1b7", "4b", "8b", "14b", "32b"];
+const TIER_ORDER = ["2b", "4b", "14b", "32b"];
 /**
  * Returns true if `requested` exceeds `ceiling`.
  * e.g. ceilingExceeded("14b", "4b") → true (14b > 4b ceiling)

package/dist/utils/groundingVerifier.js

@@ -9,9 +9,9 @@
  * stateless MCP), pointed at free-form generation instead of tool-call
  * responses.
  *
- * Cascade role: prism-coder:4b is the default verifier (fast, 2.5GB).
+ * Cascade role: qwen3.5:4b is the default verifier (fast, 2.5GB).
  * 14b drafts; 4b verifies. Different model = Patronus rule satisfied.
- * Falls back to 1b7 on devices with <4GB free RAM.
+ * Falls back to 2b on devices with <4GB free RAM.
  *
  * Failure modes:
  *   - Verifier model unreachable / timeout → fail-closed refusal
@@ -93,7 +93,7 @@ function refusalText(action, failedClaim) {
     }
 }
 export async function verifyGrounding(opts) {
-    const verifierModel = opts.verifierModel ?? "prism-coder:4b";
+    const verifierModel = opts.verifierModel ?? "qwen3.5:4b";
     const timeoutMs = opts.timeoutMs ?? 2000;
     const ollamaUrl = opts.ollamaUrl ?? PRISM_LOCAL_LLM_URL;
     const fetchImpl = opts.fetchImpl ?? fetch;

package/dist/utils/modelPicker.js

@@ -1,11 +1,12 @@
 /**
  * RAM-Gated Local Model Picker
  * ─────────────────────────────────────────────────────────────
- * Cascade: 14b (default) → 4b (verifier) → 32b (complex only).
+ * Cascade: 14b (default) → 4b (verifier) → 2b (mobile) → 32b (complex only).
  *
  * The default ceiling is "14b" — NOT "32b". This means:
  *   - 14b is the primary model for routing + general inference
  *   - 4b is used as the grounding verifier (fast, small)
+ *   - 2b is the mobile/iPhone first gate (Qwen3.5-4B Q3_K_M, 99.1% BFCL)
  *   - 32b is only loaded when caller explicitly passes ceiling="32b"
  *     or when the task requires maximum quality (complex code gen, etc.)
  *
@@ -15,9 +16,8 @@
  *   tag                 weights   need free   ctx     role
  *   prism-coder:32b     ~19 GB    ≥ 24 GB     32K    complex (on-demand)
  *   prism-coder:14b     ~ 9 GB    ≥ 12 GB     32K    default router
- *   prism-coder:8b      ~ 5 GB    ≥  7 GB     32K    fallback
- *   prism-coder:4b      ~ 2.5 GB  ≥  4 GB      8K    verifier + mobile
- *   prism-coder:1b7     ~ 2 GB    ≥  3 GB      8K    watch + ultra-low RAM
+ *   qwen3.5:4b          ~ 3.4 GB  ≥  5 GB     32K    verifier (Q4_K_M, 100%)
+ *   prism-coder:2b      ~ 2.3 GB  ≥  3 GB      8K    mobile / iPhone (Q3_K_M, 99.1%)
  *
  * Below 3 GB free → no local pick (caller must use cloud).
  */
@@ -29,9 +29,8 @@ const GB = 1024 ** 3;
 export const MODEL_TIERS = [
     { tag: 'prism-coder:32b', weightsGb: 19, minFreeGb: 24, ctxTokens: 32_768 },
     { tag: 'prism-coder:14b', weightsGb: 9, minFreeGb: 12, ctxTokens: 32_768 },
-    { tag: 'prism-coder:8b', weightsGb: 5, minFreeGb: 7, ctxTokens: 32_768 },
-    { tag: 'prism-coder:4b', weightsGb: 2.5, minFreeGb: 4, ctxTokens: 8_192 },
-    { tag: 'prism-coder:1b7', weightsGb: 2, minFreeGb: 3, ctxTokens: 8_192 },
+    { tag: 'qwen3.5: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
@@ -58,7 +57,7 @@ export function pickLocalModel(freeBytes, ceiling, available) {
     if (!Number.isFinite(freeBytes) || freeBytes <= 0)
         return null;
     const effectiveCeiling = ceiling || DEFAULT_CEILING;
-    const ceilingIdx = MODEL_TIERS.findIndex(t => t.tag.endsWith(effectiveCeiling) || t.tag === effectiveCeiling);
+    const ceilingIdx = MODEL_TIERS.findIndex(t => t.tag.endsWith(`:${effectiveCeiling}`));
     const startIdx = ceilingIdx >= 0 ? ceilingIdx : 0;
     for (let i = startIdx; i < MODEL_TIERS.length; i++) {
         const tier = MODEL_TIERS[i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "18.0.2",
+  "version": "19.0.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",