prism-mcp-server 18.0.2 → 19.0.1

package/dist/cli.js

@@ -521,10 +521,10 @@ scmCmd
 });
 // ─── prism register-models ────────────────────────────────────
 // Convenience: alias namespaced HF-style prism-coder tags
-// (`dcostenco/prism-coder:14b`) to the bare tags (`prism-coder:14b`)
+// (`dcostenco/prism-coder:9b`) to the bare tags (`prism-coder:9b`)
 // some external tooling expects. The MCP picker handles both forms
 // natively as of v15.5, so this command is OPTIONAL — useful only
-// when a user wants to run `ollama run prism-coder:14b` directly,
+// when a user wants to run `ollama run prism-coder:9b` directly,
 // or for tools that pre-date the picker's namespace fallback.
 program
     .command('register-models')

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/storage/sqlite.js

@@ -1268,7 +1268,7 @@ export class SqliteStorage {
             FROM session_ledger
             WHERE project = ? AND user_id = ? AND role = ?
               AND event_type = 'correction'
-              AND importance >= 3
+              AND importance >= 0
               AND deleted_at IS NULL
               AND archived_at IS NULL
             ORDER BY importance DESC
@@ -2323,10 +2323,12 @@ export class SqliteStorage {
             SET importance = MAX(0, importance - 1)
             WHERE project = ? AND user_id = ?
               AND importance > 0
+              AND importance < 10
               AND event_type != 'session'
               AND created_at < datetime('now', '-' || ? || ' days')
+              AND (last_accessed_at IS NULL OR last_accessed_at < datetime('now', '-' || ? || ' days'))
               AND deleted_at IS NULL`,
-            args: [project, userId, decayDays],
+            args: [project, userId, decayDays, decayDays],
         });
         const decayed = result.rowsAffected || 0;
         if (decayed > 0) {

package/dist/tools/behavioralVerifierHandler.js

@@ -0,0 +1,79 @@
+/**
+ * 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";
+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) {
+        console.error("[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) {
+            console.error(`[verify-behavior] ⚠️ portal returned ${res.status} — fail-closed. URL: ${url}`);
+            return FALLBACK_SCENARIO;
+        }
+        const data = (await res.json());
+        return formatResult(data);
+    }
+    catch (err) {
+        console.error(`[verify-behavior] ⚠️ VERIFICATION FAILED: ${err.message} — using generic fallback`);
+        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.
@@ -980,15 +977,17 @@ export async function sessionLoadContextHandler(args) {
     // Build the response object before v4.0 augmentations
     // SECURITY: Wrap output in boundary tags to prevent context confusion.
     // The LLM sees <prism_memory context="historical"> and knows this is data, not instructions.
-    let responseText = `${MEMORY_BOUNDARY_PREFIX}📋 Session context for "${project}" (${level}):\n\n${formattedContext.trim()}${splitBrainWarning}${driftReport}${briefingBlock}${sdmRecallBlock}${greetingBlock}${visualMemoryBlock}${skillBlock}${versionNote}`;
-    // ─── v4.0: Behavioral Warnings Injection ───────────────────
-    // If loadContext returned behavioral_warnings, add them to the
-    // formatted output so the agent sees them prominently.
+    // ─── v19.1: Behavioral Warnings — BEFORE skills (protected from truncation) ───
+    // Corrections must surface prominently. Placed before skillBlock so the
+    // skill budget cannot push them out. Capped at 2,000 chars.
     const behavWarnings = data?.behavioral_warnings;
+    let behavBlock = '';
     if (behavWarnings && behavWarnings.length > 0) {
-        responseText += `\n\n[⚠️ BEHAVIORAL WARNINGS]\n` +
+        const rawBlock = `\n\n[⚠️ BEHAVIORAL WARNINGS — DO NOT IGNORE]\n` +
             behavWarnings.map(w => `- ${w.summary} (importance: ${w.importance})`).join("\n");
+        behavBlock = [...rawBlock].slice(0, 2000).join('');
     }
+    let responseText = `${MEMORY_BOUNDARY_PREFIX}📋 Session context for "${project}" (${level}):\n\n${formattedContext.trim()}${splitBrainWarning}${driftReport}${briefingBlock}${sdmRecallBlock}${greetingBlock}${visualMemoryBlock}${behavBlock}${skillBlock}${versionNote}`;
     // ─── v9.4.7: ABA Precision Protocol (foundational) ────────
     // Injected into EVERY session load so the agent always operates
     // under these behavioral rules. Never truncated (placed before

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/14B/8B/1.7B) auto-selected by free
+ * model via Ollama. Tiers (32B/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 (14B/32B/Claude by tier)
+ *        - portal runs its own cascade (9B/32B/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
@@ -24,16 +24,15 @@ import { getSynaluxJwt, invalidateSynaluxJwt } from "../utils/synaluxJwt.js";
 import { getAvailableMemoryBytes } from "../utils/availableMemory.js";
 import { PRISM_SYNALUX_BASE_URL, PRISM_LOCAL_LLM_URL, } from "../config.js";
 import { debugLog } from "../utils/logger.js";
-import { verifyGrounding } from "../utils/groundingVerifier.js";
 import { getEntitlements, clampCeiling } from "../utils/entitlements.js";
 import { ddLog } from "../utils/ddLogger.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 / 14B / 8B / 1.7B — based on free RAM at call time, " +
+        "Picks the largest viable tier — 32B / 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 (14B → 32B → Claude Opus 4.7) " +
+        "Falls through to the synalux portal cloud cascade (9B → 32B → 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.",
@@ -60,8 +59,8 @@ export const PRISM_INFER_TOOL = {
             },
             model_ceiling: {
                 type: "string",
-                enum: ["32b", "14b", "8b", "1b7"],
-                description: "Cap the largest tier the picker may select. e.g. '14b' forbids 32B even if RAM allows.",
+                enum: ["32b", "9b", "4b", "2b"],
+                description: "Cap the largest tier the picker may select. e.g. '9b' forbids 32B even if RAM allows.",
             },
             cloud_fallback: {
                 type: "boolean",
@@ -70,7 +69,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, 9B=60s, 4B=20s, 1.7B=15s.",
             },
             evidence: {
                 type: "array",
@@ -91,12 +90,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 +123,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", "9b", "4b", "2b"].includes(a.model_ceiling))
         return false;
     if (a.verify !== undefined && typeof a.verify !== "boolean")
         return false;
@@ -148,9 +147,9 @@ export function isPrismInferArgs(args) {
 // ─── Ollama helpers ────────────────────────────────────────────
 const DEFAULT_TIMEOUTS = {
     "prism-coder:32b": 120_000,
-    "prism-coder:14b": 60_000,
-    "prism-coder:8b": 30_000,
-    "prism-coder:1b7": 15_000,
+    "prism-coder:9b": 60_000,
+    "prism-coder: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 +329,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++) {
@@ -407,10 +406,10 @@ export async function runInfer(args, deps) {
  */
 async function applyVerification(draft, args, deps, partial) {
     const shouldVerify = args.verify ?? (args.evidence !== undefined && args.evidence.length > 0);
-    if (!shouldVerify) {
+    if (!shouldVerify || !deps.callVerifier) {
         return { ...partial, output: draft };
     }
-    const verifier = deps.callVerifier ?? verifyGrounding;
+    const verifier = deps.callVerifier;
     const outcome = await verifier({
         draft,
         evidence: args.evidence ?? [],

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

@@ -6,7 +6,7 @@
  * to enforce model ceiling, max_tokens, and feature gates.
  *
  * Unauthenticated users (no SYNALUX_API_KEY) get free-tier defaults.
- * Authenticated users get their plan from the portal (1-hour cache).
+ * Authenticated users get their plan from the portal (5-minute cache).
  */
 import { getSynaluxJwt } from "./synaluxJwt.js";
 import { PRISM_SYNALUX_BASE_URL, SYNALUX_CONFIGURED } from "../config.js";
@@ -32,10 +32,10 @@ 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", "9b", "32b"];
 /**
  * Returns true if `requested` exceeds `ceiling`.
- * e.g. ceilingExceeded("14b", "4b") → true (14b > 4b ceiling)
+ * e.g. ceilingExceeded("9b", "4b") → true (9b > 4b ceiling)
  */
 export function ceilingExceeded(requested, ceiling) {
     const reqIdx = TIER_ORDER.indexOf(requested);
@@ -79,12 +79,18 @@ async function fetchEntitlements() {
             redirect: "error",
         });
         if (!res.ok) {
-            debugLog(`[entitlements] portal HTTP ${res.status} — free tier fallback`);
+            debugLog(`[entitlements] portal HTTP ${res.status}`);
+            if (cache) {
+                debugLog("[entitlements] using last-known-good (safety fail-closed)");
+                return cache.entitlements;
+            }
             return FREE_ENTITLEMENTS;
         }
         const data = (await res.json());
         if (!data.plan || !data.model_ceiling) {
-            debugLog("[entitlements] malformed response — free tier fallback");
+            debugLog("[entitlements] malformed response");
+            if (cache)
+                return cache.entitlements;
             return FREE_ENTITLEMENTS;
         }
         debugLog(`[entitlements] plan=${data.plan} ceiling=${data.model_ceiling} ` +
@@ -92,7 +98,14 @@ async function fetchEntitlements() {
         return data;
     }
     catch (err) {
-        debugLog(`[entitlements] fetch error: ${err instanceof Error ? err.message : String(err)} — free tier fallback`);
+        debugLog(`[entitlements] fetch error: ${err instanceof Error ? err.message : String(err)}`);
+        // F1 fix: fail-closed — keep last-known-good entitlements on fetch error.
+        // Safety controls (grounding_verifier) must not degrade on availability failures.
+        if (cache) {
+            debugLog("[entitlements] using last-known-good (safety fail-closed)");
+            return cache.entitlements;
+        }
+        debugLog("[entitlements] no cached entitlements — free tier fallback (cold start)");
         return FREE_ENTITLEMENTS;
     }
 }
@@ -111,7 +124,14 @@ export async function getEntitlements() {
     inFlight = (async () => {
         try {
             const ent = await fetchEntitlements();
-            cache = { entitlements: ent, expiresAt: Date.now() + CACHE_TTL_MS };
+            // Only update cache if this is a REAL fetch (not a cached fallback).
+            // fetchEntitlements returns cache.entitlements on error — detect by
+            // checking if the returned object is the exact same reference.
+            const isFallback = cache && ent === cache.entitlements;
+            if (!isFallback) {
+                cache = { entitlements: ent, expiresAt: Date.now() + CACHE_TTL_MS };
+            }
+            // On fallback: DON'T refresh expiresAt — let it expire so we retry.
             return ent;
         }
         finally {

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;