prism-mcp-server 20.2.0 → 20.2.2

package/dist/tools/taskRouterHandler.js

@@ -38,8 +38,8 @@ const CLAW_KEYWORDS = [
     "add field", "add column", "add property",
     "remove unused", "delete unused", "clean up",
 ];
-/** Keywords that suggest the task requires the host model's reasoning. */
-const HOST_KEYWORDS = [
+/** Reserved judgment or host-tool boundaries that local inference cannot own. */
+const HOST_BOUNDARY_KEYWORDS = [
     "architect", "architecture", "redesign", "design system",
     "debug complex", "investigate", "root cause", "diagnose",
     "security audit", "vulnerability", "penetration",
@@ -49,10 +49,56 @@ const HOST_KEYWORDS = [
     "migration strategy", "data migration",
     "api design", "schema design", "database design",
     "code review", "review the", "analyze the",
-    "explain how", "explain why", "understand",
-    "complex logic", "algorithm", "concurrent", "race condition",
+    "concurrent", "race condition",
     "integrate multiple", "cross-cutting",
-    "plan", "strategy", "roadmap",
+    "implementation plan", "create a plan", "strategy", "roadmap",
+];
+/** Explicit workflows that require host-side tools or external state. */
+const HOST_TOOL_WORKFLOW_KEYWORDS = [
+    "inspect the repository", "search the repository", "read files",
+    "run command", "execute command", "run the tests", "run tests",
+    "apply the patch", "edit the file", "modify the file",
+    "commit", "push", "deploy", "publish",
+    "use the browser", "query the database", "database query",
+];
+/**
+ * Natural-language action groups that reveal a repository workflow even when
+ * the prompt does not use one of the exact phrases above. Local inference can
+ * draft a bounded artifact, but it cannot own a read -> mutate -> verify tool
+ * sequence. Requiring two distinct groups avoids treating a single request
+ * such as "update version" as a host-only workflow.
+ */
+const HOST_TOOL_ACTION_GROUPS = [
+    {
+        label: "repository inspection",
+        patterns: [
+            /\b(?:read|inspect|search|open)\b[^.!?\n]{0,100}\b(?:repository|repo|codebase|source|files?|test harness)\b/i,
+        ],
+    },
+    {
+        label: "workspace mutation",
+        patterns: [
+            /\b(?:persist|save|update|edit|modify|apply)\b[^.!?\n]{0,100}\b(?:regression tests?|tests?|files?|code|source|workflow|harness|patch|repository|repo)\b/i,
+        ],
+    },
+    {
+        label: "execution or verification",
+        patterns: [
+            /\b(?:run|execute)\b[^.!?\n]{0,100}\b(?:tests?|test suite|verification|build|type-?check|lint|commands?)\b/i,
+            /\b(?:verify|validate)\b[^.!?\n]{0,100}\b(?:tests?|build|behavior|workflow)\b/i,
+        ],
+    },
+];
+/** Complexity signals that should select 27B when the task is bounded. */
+const HIGH_COMPLEXITY_KEYWORDS = [
+    "complex logic", "algorithm", "dynamic programming", "constraint solver",
+    "parser", "compiler", "state machine", "graph traversal", "backtracking",
+    "multiple edge cases", "complete specification",
+];
+/** Evidence that a difficult request is still a self-contained inference job. */
+const BOUNDED_TASK_MARKERS = [
+    "self-contained", "standalone", "bounded", "single function", "one function",
+    "single file", "one file", "pure function", "complete specification",
 ];
 /** Conjunctions and sequential markers that indicate multi-step tasks. */
 const MULTI_STEP_MARKERS = [
@@ -64,6 +110,15 @@ const MULTI_STEP_MARKERS = [
     // Note: removed bare "1.", "2.", "3." — too many false positives
     // on version numbers (v1.2.3), decimals, and IP addresses.
 ];
+const MAX_BOUNDED_FILES = 2;
+const MAX_HOST_ROUTABLE_FILES = 5;
+const MULTI_STEP_HOST_THRESHOLD = 2;
+const HOST_TOOL_ACTION_GROUP_THRESHOLD = 2;
+const HIGH_COMPLEXITY_MIN_SCORE = 7;
+const VERY_HIGH_COMPLEXITY_MIN_SCORE = 8;
+const VERY_HIGH_COMPLEXITY_SIGNAL_COUNT = 2;
+const BOUNDED_HIGH_COMPLEXITY_CONFIDENCE = 0.85;
+const HARD_HOST_BOUNDARY_CONFIDENCE = 0.95;
 // ─── Heuristic Engine ────────────────────────────────────────
 /**
  * Count how many keywords from a list appear in the text (case-insensitive).
@@ -78,19 +133,65 @@ function countKeywordHits(text, keywords) {
     }
     return hits;
 }
+function findHostToolActionGroups(description) {
+    return HOST_TOOL_ACTION_GROUPS
+        .filter(({ patterns }) => patterns.some((pattern) => pattern.test(description)))
+        .map(({ label }) => label);
+}
 /**
  * Compute a claw-affinity score from keyword analysis.
  * Returns a value between -1.0 (strongly host) and +1.0 (strongly claw).
  */
 function keywordSignal(description) {
     const clawHits = countKeywordHits(description, CLAW_KEYWORDS);
-    const hostHits = countKeywordHits(description, HOST_KEYWORDS);
+    const hostHits = countKeywordHits(description, HOST_BOUNDARY_KEYWORDS);
     const total = clawHits + hostHits;
     if (total === 0)
         return 0; // No signal — neutral
     // Normalized difference: positive = claw, negative = host
     return (clawHits - hostHits) / total;
 }
+/**
+ * Decide whether the task is eligible for local inference independently from
+ * how much model capacity it needs. A hard host boundary always wins.
+ */
+function assessDelegability(args) {
+    const description = args.task_description;
+    const files = args.files_involved;
+    const boundaryKeywordHits = countKeywordHits(description, HOST_BOUNDARY_KEYWORDS);
+    const toolWorkflowHits = countKeywordHits(description, HOST_TOOL_WORKFLOW_KEYWORDS);
+    const toolActionGroups = findHostToolActionGroups(description);
+    const multiStepHits = countKeywordHits(description, MULTI_STEP_MARKERS);
+    const highComplexityHits = countKeywordHits(description, HIGH_COMPLEXITY_KEYWORDS);
+    const boundedByFiles = Boolean(files && files.length > 0 && files.length <= MAX_BOUNDED_FILES);
+    const boundedByDescription = countKeywordHits(description, BOUNDED_TASK_MARKERS) > 0;
+    const reasons = [];
+    if (boundaryKeywordHits > 0)
+        reasons.push("reserved host judgment");
+    if (toolWorkflowHits > 0)
+        reasons.push("host tools or external state required");
+    if (toolActionGroups.length >= HOST_TOOL_ACTION_GROUP_THRESHOLD) {
+        reasons.push(`host workflow actions: ${toolActionGroups.join(", ")}`);
+    }
+    if (multiStepHits >= MULTI_STEP_HOST_THRESHOLD)
+        reasons.push("multi-step workflow");
+    if ((files?.length ?? 0) > MAX_HOST_ROUTABLE_FILES)
+        reasons.push("cross-file scope");
+    if (args.estimated_scope === "refactor")
+        reasons.push("refactor scope");
+    const minimumComplexity = highComplexityHits >= VERY_HIGH_COMPLEXITY_SIGNAL_COUNT
+        ? VERY_HIGH_COMPLEXITY_MIN_SCORE
+        : highComplexityHits > 0
+            ? HIGH_COMPLEXITY_MIN_SCORE
+            : 1;
+    return {
+        hardHostBoundary: reasons.length > 0,
+        boundedHighComplexity: highComplexityHits > 0 && (boundedByFiles || boundedByDescription),
+        highComplexityHits,
+        minimumComplexity,
+        reasons,
+    };
+}
 /**
  * Compute a claw-affinity score from file count.
  * ≤2 files → strongly claw (+1.0)
@@ -193,6 +294,22 @@ const WEIGHTS = {
     length: 0.10,
     multiStep: 0.10,
 };
+/**
+ * Forward the deterministic complexity signal without choosing a model.
+ * prism_infer owns tier/thinking selection because it also sees the loaded
+ * memory size, installed models, live RAM, entitlements, and explicit caller
+ * overrides.
+ */
+function buildRecommendedArgs(args, complexityScore) {
+    return {
+        prompt: args.task_description,
+        ...(args.project ? { project: args.project } : {}),
+        mode: "code",
+        task_complexity: complexityScore,
+        cloud_fallback: false,
+        escalation: "report",
+    };
+}
 // ─── Router Core ─────────────────────────────────────────────
 /**
  * Compute the routing recommendation. Pure function.
@@ -216,6 +333,7 @@ export function computeRoute(args) {
     const sc = scopeSignal(estimated_scope);
     const ln = lengthSignal(task_description);
     const ms = multiStepSignal(task_description);
+    const delegability = assessDelegability(args);
     // ── Weighted composite score: [-1.0, +1.0] ──
     // Positive = claw-favoring, Negative = host-favoring
     const composite = kw * WEIGHTS.keyword +
@@ -228,12 +346,20 @@ export function computeRoute(args) {
     // composite +1.0 → complexity 1 (trivial)
     // composite -1.0 → complexity 10 (very complex)
     const complexityRaw = Math.round(5.5 - composite * 4.5);
-    const complexity_score = Math.max(1, Math.min(10, complexityRaw));
+    const complexity_score = Math.max(delegability.minimumComplexity, Math.max(1, Math.min(10, complexityRaw)));
     // ── Determine target ──
-    const isClaw = composite > 0 && complexity_score <= PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY;
+    const locallyEligible = composite > 0 || delegability.boundedHighComplexity;
+    const isClaw = !delegability.hardHostBoundary &&
+        locallyEligible &&
+        complexity_score <= PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY;
     // ── Confidence: distance from the decision boundary ──
     // Higher absolute composite → higher confidence
-    const confidence = Math.min(0.99, Math.round((0.5 + Math.abs(composite) * 0.5) * 100) / 100);
+    const rawConfidence = Math.min(0.99, Math.round((0.5 + Math.abs(composite) * 0.5) * 100) / 100);
+    const confidence = delegability.hardHostBoundary
+        ? Math.max(rawConfidence, HARD_HOST_BOUNDARY_CONFIDENCE)
+        : delegability.boundedHighComplexity
+            ? Math.max(rawConfidence, BOUNDED_HIGH_COMPLEXITY_CONFIDENCE)
+            : rawConfidence;
     // ── Apply confidence threshold ──
     // If confidence is too low, default to host (safer)
     const target = isClaw && confidence >= PRISM_TASK_ROUTER_CONFIDENCE_THRESHOLD ? "claw" : "host";
@@ -251,6 +377,12 @@ export function computeRoute(args) {
         signals.push(`multi-step detected (${ms.toFixed(1)})`);
     if (ln !== 0)
         signals.push(`length signal: ${ln.toFixed(1)}`);
+    if (delegability.boundedHighComplexity) {
+        signals.push(`bounded high-complexity workload (${delegability.highComplexityHits} signal${delegability.highComplexityHits === 1 ? "" : "s"})`);
+    }
+    if (delegability.hardHostBoundary) {
+        signals.push(`host boundary: ${delegability.reasons.join(", ")}`);
+    }
     const rationale = target === "claw"
         ? `Task is delegable to the local agent. Signals: ${signals.join("; ") || "neutral"}.`
         : `Task should remain with the host model. Signals: ${signals.join("; ") || "neutral"}.`;
@@ -259,8 +391,14 @@ export function computeRoute(args) {
         confidence,
         complexity_score,
         rationale,
-        recommended_tool: target === "claw" ? "claw_run_task" : null,
+        recommended_tool: target === "claw" ? "prism_infer" : null,
+        ...(target === "claw" ? {
+            recommended_args: buildRecommendedArgs(args, complexity_score),
+        } : {}),
         _rawComposite: composite,
+        _hardHostBoundary: delegability.hardHostBoundary,
+        _boundedHighComplexity: delegability.boundedHighComplexity,
+        _minimumComplexity: delegability.minimumComplexity,
     };
 }
 // ─── MCP Handler ─────────────────────────────────────────────
@@ -282,9 +420,9 @@ export async function sessionTaskRouteHandler(args) {
             isError: true,
         };
     }
-    // Delegation opt-in gate: if delegation_enabled is not "true", always route to host.
-    // This enforces the prism-infer-delegation skill's "off by default" rule in code.
-    const delegationEnabled = await getSetting("delegation_enabled", "false");
+    // Local-first is the product default. An explicit dashboard/config value of
+    // "false" remains an operator-owned opt-out and always routes to the host.
+    const delegationEnabled = await getSetting("delegation_enabled", "true");
     if (delegationEnabled !== "true") {
         return {
             content: [{
@@ -293,7 +431,7 @@ export async function sessionTaskRouteHandler(args) {
                         target: "host",
                         confidence: 1.0,
                         complexity_score: 5,
-                        rationale: "Delegation is off (default). Enable with: configure_notifications({setting: 'delegation_enabled', value: 'true'}) or via the Prism dashboard.",
+                        rationale: "Local delegation was explicitly disabled in Prism settings.",
                         recommended_tool: null,
                         delegation_enabled: false,
                     }),
@@ -313,14 +451,25 @@ export async function sessionTaskRouteHandler(args) {
                 const adjustedComposite = Math.max(-1.0, Math.min(1.0, (result._rawComposite || 0) + exp.bias));
                 // Recalculate target and complexity if bias flipped the composite sign
                 const complexityRaw = Math.round(5.5 - adjustedComposite * 4.5);
-                const complexity_score = Math.max(1, Math.min(10, complexityRaw));
-                const isClaw = adjustedComposite > 0 && complexity_score <= PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY;
-                const confidence = Math.min(0.99, Math.round((0.5 + Math.abs(adjustedComposite) * 0.5) * 100) / 100);
+                const complexity_score = Math.max(result._minimumComplexity ?? 1, Math.max(1, Math.min(10, complexityRaw)));
+                const locallyEligible = adjustedComposite > 0 || result._boundedHighComplexity === true;
+                const isClaw = result._hardHostBoundary !== true &&
+                    locallyEligible &&
+                    complexity_score <= PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY;
+                const rawConfidence = Math.min(0.99, Math.round((0.5 + Math.abs(adjustedComposite) * 0.5) * 100) / 100);
+                const confidence = result._hardHostBoundary
+                    ? Math.max(rawConfidence, HARD_HOST_BOUNDARY_CONFIDENCE)
+                    : result._boundedHighComplexity
+                        ? Math.max(rawConfidence, BOUNDED_HIGH_COMPLEXITY_CONFIDENCE)
+                        : rawConfidence;
                 const target = isClaw && confidence >= PRISM_TASK_ROUTER_CONFIDENCE_THRESHOLD ? "claw" : "host";
                 result.target = target;
                 result.confidence = confidence;
                 result.complexity_score = complexity_score;
-                result.recommended_tool = target === "claw" ? "claw_run_task" : null;
+                result.recommended_tool = target === "claw" ? "prism_infer" : null;
+                result.recommended_args = target === "claw"
+                    ? buildRecommendedArgs(args, complexity_score)
+                    : undefined;
                 result.experience = {
                     bias: exp.bias,
                     sample_count: exp.sampleCount,
@@ -333,8 +482,6 @@ export async function sessionTaskRouteHandler(args) {
             // Note: intentionally throwing away the error to keep the original raw heuristic result.
         }
     }
-    // Remove the private field from the final output
-    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:9b to break the tie. This is purely additive — if the
@@ -345,20 +492,28 @@ export async function sessionTaskRouteHandler(args) {
             const llmTarget = await askLocalLlmForRoute(args.task_description);
             if (llmTarget) {
                 const prev = result.target;
-                result.target = llmTarget;
-                // Re-derive complexity_score to stay consistent with the new target
-                // so downstream consumers see a coherent { target, complexity_score } pair.
-                if (llmTarget === "claw" && result.complexity_score > PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY) {
-                    result.complexity_score = PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY;
-                }
+                const llmCanDelegate = llmTarget === "claw" &&
+                    result._hardHostBoundary !== true &&
+                    result.complexity_score <= PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY;
+                const target = llmCanDelegate ? "claw" : "host";
+                result.target = target;
+                result.recommended_tool = target === "claw" ? "prism_infer" : null;
+                result.recommended_args = target === "claw"
+                    ? buildRecommendedArgs(args, result.complexity_score)
+                    : undefined;
                 result.rationale +=
-                    ` [prism-coder override: heuristic confidence ${result.confidence.toFixed(2)} < threshold → LLM voted "${llmTarget}" (was "${prev}")]`;
+                    ` [prism-coder review: heuristic confidence ${result.confidence.toFixed(2)} < threshold → LLM voted "${llmTarget}"; resolved "${target}" (was "${prev}")]`;
             }
         }
         catch {
             // Non-fatal: LLM second-opinion failure never blocks routing
         }
     }
+    // Remove internal decision evidence from the public tool response.
+    delete result._rawComposite;
+    delete result._hardHostBoundary;
+    delete result._boundedHighComplexity;
+    delete result._minimumComplexity;
     return {
         content: [
             {
@@ -382,8 +537,8 @@ async function askLocalLlmForRoute(description) {
         .replace(/</g, "&lt;").replace(/>/g, "&gt;");
     const prompt = `You are a task routing classifier for an AI coding assistant.\n` +
         `Decision logic:\n` +
-        `  - "claw": simple, isolated, well-defined tasks (rename file, fix typo, add test)\n` +
-        `  - "host": complex, multi-step, architectural, or ambiguous tasks (audit, redesign, plan)\n\n` +
+        `  - "claw": bounded, self-contained, well-defined inference work. It may be difficult if it needs no host tools or reserved judgment.\n` +
+        `  - "host": architecture, security, investigation, review, multi-step/tool-required workflows, or ambiguous work.\n\n` +
         `CRITICAL: You MUST use the following structural tags:\n` +
         `<|synalux_think|>\n[Internal reasoning about complexity]\n</|synalux_think|>\n\n` +
         `<|tool_call|>\nclaw\n</|tool_call|>\n\n` +

package/dist/utils/entitlements.js

@@ -68,7 +68,11 @@ export function clampCeiling(requested, planCeiling) {
 }
 // ── Fetch ─────────────────────────────────────────────────────────
 async function fetchEntitlements() {
-    if (!SYNALUX_CONFIGURED || !PRISM_SYNALUX_BASE_URL) {
+    // Re-read process.env because dashboard/bootstrap configuration can inject
+    // credentials after config.ts captured its module-load constants.
+    const baseUrl = process.env.PRISM_SYNALUX_BASE_URL?.trim() || PRISM_SYNALUX_BASE_URL;
+    const apiKey = process.env.PRISM_SYNALUX_API_KEY?.trim();
+    if ((!SYNALUX_CONFIGURED && !apiKey) || !baseUrl) {
         debugLog("[entitlements] no Synalux auth configured — free tier");
         return { ...FREE_ENTITLEMENTS, source: "unconfigured" };
     }
@@ -78,7 +82,7 @@ async function fetchEntitlements() {
         return { ...FREE_ENTITLEMENTS, source: "fallback_free" };
     }
     try {
-        const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism/entitlements`;
+        const url = `${baseUrl}/api/v1/prism/entitlements`;
         const res = await fetch(url, {
             method: "GET",
             headers: { Authorization: `Bearer ${jwt}` },

package/dist/utils/inferenceMetrics.js

@@ -13,6 +13,8 @@
  */
 import { debugLog } from "./logger.js";
 import { appendInferMetric, queryInferMetrics } from "../storage/inferMetricsLedger.js";
+import { ingestPanelMetrics } from "../storage/panelMetricsSpool.js";
+const PANEL_CALLER = "panel";
 // T1 fix: content-aware token estimator. Replaces flat text.length / 4 which
 // underestimates emoji (~2 UTF-16 units but 1.5-2.5 BPE tokens) and CJK
 // (~1 char ≈ 1 token) by 15-40%, and overestimates dense code (~3.3 chars/token).
@@ -169,9 +171,13 @@ export function resetInferenceMetrics() {
 }
 export async function inferenceMetricsHandler(args) {
     if (args?.period === "all") {
+        const ingest = await ingestPanelMetrics();
         const agg = await queryInferMetrics();
         if (!agg || agg.total === 0) {
-            return { content: [{ type: "text", text: "No persisted prism_infer calls yet (ledger empty)." }] };
+            const warning = ingest.failed_files > 0
+                ? ` Panel spool ingestion failed for ${ingest.failed_files} file(s); retained for retry.`
+                : "";
+            return { content: [{ type: "text", text: `No persisted inference calls yet (ledger empty).${warning}` }] };
         }
         const localPct = agg.total ? Math.round((agg.local / agg.total) * 100) : 0;
         const cloudPct = agg.total ? Math.round((agg.cloud / agg.total) * 100) : 0;
@@ -181,13 +187,26 @@ export async function inferenceMetricsHandler(args) {
         const byB = Object.entries(agg.by_backend)
             .sort((a, b) => b[1] - a[1])
             .map(([k, v]) => `  ${k}: ${v}`).join("\n");
+        const panel = agg.by_caller[PANEL_CALLER];
+        const panelPct = panel?.total ? Math.round((panel.local / panel.total) * 100) : 0;
+        const panelLine = panel
+            ? `Panel local serve rate: ${panelPct}% (${panel.local}/${panel.total}; cloud ${panel.cloud})`
+            : "Panel local serve rate: no panel calls recorded";
+        let ingestNote = "";
+        if (ingest.invalid > 0)
+            ingestNote = `discarded ${ingest.invalid} invalid panel row(s)`;
+        if (ingest.failed_files > 0) {
+            ingestNote += `${ingestNote ? "; " : ""}retained ${ingest.failed_files} panel file(s) for retry`;
+        }
+        const ingestLine = ingestNote ? `\nPanel spool: ${ingestNote}` : "";
         return {
             content: [{
                     type: "text",
-                    text: `📊 Delegation Metrics — ALL TIME (persisted ledger, ${span})\n` +
+                    text: `📊 Inference Metrics — ALL TIME (persisted ledger, ${span})\n` +
                         `Total calls: ${agg.total} — Local: ${agg.local} (${localPct}%) | Cloud: ${agg.cloud} (${cloudPct}%)\n` +
+                        `${panelLine}\n` +
                         `Prompt tokens: ${agg.prompt_tokens} | Completion tokens: ${agg.completion_tokens}\n` +
-                        `Avg latency: ${agg.avg_latency_ms}ms\nBy backend:\n${byB}`,
+                        `Avg latency: ${agg.avg_latency_ms}ms\nBy backend:\n${byB}${ingestLine}`,
                 }],
         };
     }

package/dist/utils/modelPicker.js

@@ -13,10 +13,10 @@
  * This saves 11GB+ RAM vs 27b and keeps response times fast.
  *
  *   tag                 weights   need free   ctx     role
- *   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:27b     ~16 GB    ≥ 20 GB      4K    quality (on-demand, Qwen3.5 DeltaNet, 100% BFCL)
+ *   prism-coder:9b      ~ 5.8 GB  ≥  8 GB      4K    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%)
+ *   prism-coder:2b      ~ 2.3 GB  ≥  3 GB     32K    mobile / iPhone (Qwen3.5, 99.1%)
  *
  * Below 3 GB free → no local pick (caller must use cloud).
  */

package/dist/utils/synaluxJwt.js

@@ -32,7 +32,12 @@ let inFlight = null;
  * Concurrent callers share a single in-flight exchange (no thundering herd).
  */
 export async function getSynaluxJwt() {
-    if (!PRISM_SYNALUX_BASE_URL || !PRISM_SYNALUX_API_KEY) {
+    // Re-read process.env because storage/dashboard configuration can inject
+    // credentials after config.ts captured its module-load constants.
+    const baseUrl = process.env.PRISM_SYNALUX_BASE_URL?.trim() ||
+        process.env.SYNALUX_BASE_URL?.trim() || PRISM_SYNALUX_BASE_URL;
+    const apiKey = process.env.PRISM_SYNALUX_API_KEY?.trim() || PRISM_SYNALUX_API_KEY;
+    if (!baseUrl || !apiKey) {
         return null;
     }
     const now = Date.now();
@@ -43,11 +48,11 @@ export async function getSynaluxJwt() {
         return inFlight;
     inFlight = (async () => {
         try {
-            const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/auth/jwt`;
+            const url = `${baseUrl}/api/v1/auth/jwt`;
             const res = await fetch(url, {
                 method: "POST",
                 headers: {
-                    "Authorization": `Bearer ${PRISM_SYNALUX_API_KEY}`,
+                    "Authorization": `Bearer ${apiKey}`,
                     "Content-Type": "application/json",
                 },
                 signal: AbortSignal.timeout(10_000),

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.2.0",
+  "version": "20.2.2",
   "mcpName": "io.github.dcostenco/prism-coder",
-  "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
+  "description": "Prism Coder — 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 or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
   "type": "module",
   "main": "dist/server.js",
@@ -16,6 +16,8 @@
     "dist"
   ],
   "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "prebuild": "npm run clean",
     "build": "tsc && npm run chmod-bins",
     "chmod-bins": "node -e \"['dist/cli.js','dist/server.js','dist/utils/universalImporter.js'].forEach(f => { try { require('fs').chmodSync(f, 0o755); } catch (e) { console.warn('chmod skipped', f, e.message); } })\"",
     "prepublishOnly": "npm run build",
@@ -25,6 +27,8 @@
     "test:watch": "vitest",
     "test:load": "vitest run tests/load/",
     "test:ci": "vitest run --reporter=junit --outputFile=test-results.xml",
+    "test:routing:live": "npm run build && node scripts/prism-infer-live-test.mjs",
+    "test:routing:models": "npm run build && node scripts/prism-infer-live-test.mjs --infer",
     "test:mcp": "node ./test_cross_mcp.js",
     "import": "node dist/utils/universalImporter.js"
   },