prism-mcp-server 16.2.0 → 17.0.0

package/README.md

@@ -157,6 +157,18 @@ Categories: abstention, adversarial traps, cascade, disambiguation, edge cases,
 ### 🔍 L3 Grounding Verifier
 When `prism_infer` receives an `evidence` payload, the grounding verifier automatically checks the model's response against the provided evidence before returning to the caller. Unverified or hallucinated claims are flagged. This is the third layer (L3) of the cascade — after tool routing (L1) and confidence gating (L2).
 
+### 🧠 HRR Semantic Drift Detection (v17.0)
+Detects when long AI agent sessions drift from their original goal — using Holographic Reduced Representations for temporal trajectory encoding and anomaly detection.
+
+**Three domains, one detector:**
+| Domain | Signals | Safety |
+|---|---|---|
+| **BCBA/Clinical** | Client specificity decay, function-intervention alignment (4 functions), contraindication detection (epilepsy/pica/dysphagia/diabetes) | PHI-safe, deterministic |
+| **Coding** | File scope entropy, summary vagueness, test coverage ratio, trajectory HRR divergence | Adaptive threshold for refactors |
+| **AAC** | Prediction accuracy, vocabulary stagnation, topic divergence | Emergency phrases always ≥ 0.95 |
+
+**Research-backed:** trajectory association (Frady et al. 2018), HDAD anomaly detection (Wang et al. 2021), unit-modulus projection (Ganesan et al. NeurIPS 2021). 306 tests across 8 files, zero failures. Use `session_detect_drift` with optional `domain` parameter.
+
 ### ⚡ Zero-search retrieval *(new in v15.8)*
 Holographic Reduced Representations (HRR) via Rust WASM for instant memory retrieval without a database query.
 
@@ -364,7 +376,7 @@ python3 tests/benchmarks/cascade-14b-32b-opus/cascade_eval.py
 |---|---|---|
 | Per-model BFCL | [`tests/benchmarks/prism-routing-100/`](tests/benchmarks/prism-routing-100/) | Solo accuracy per model, 12 categories |
 | Cascade vs Opus | [`tests/benchmarks/cascade-14b-32b-opus/`](tests/benchmarks/cascade-14b-32b-opus/) | Tier distribution, Opus engagement rate, cascade accuracy |
-| LoCoMo-Plus (Cognitive) | `/tmp/Locomo-Plus/` | Long-context dialogue coherence and historical memory retention |
+| LoCoMo-Plus (Cognitive) | [`dcostenco/Locomo-Plus`](https://github.com/dcostenco/Locomo-Plus) | Long-context dialogue coherence and historical memory retention |
 
 ### Cognitive Dialogue Memory (LoCoMo-Plus Benchmark)
 
@@ -372,21 +384,27 @@ LoCoMo-Plus is a long-context, multi-day dialogue benchmark designed to test an
 
 The **Cognitive** subset (401 multi-day dialogue scenarios) was evaluated head-to-head comparing raw baseline models against the **Prism-MCP** framework (using local SQLite semantic memory). Graded by a neutral `gemini-2.5-flash` model acting as judge (scoring on coherence, continuity, and fact accuracy):
 
-| Configuration | Total Samples | Total Score | Average Score | Absolute Delta | Relative Error Reduction |
+| Configuration | Samples | Total Score | Average Score | Absolute Delta | Relative Error Reduction |
 | :--- | :---: | :---: | :---: | :---: | :---: |
 | **Gemini-2.5-flash (Baseline)** | 401 | 278.0 / 401 | **69.33%** | — | — |
-| **Prism-MCP (Gemini-2.5-flash + Memory)** | 401 | 361.0 / 401 | **90.02%** | **+20.69%** | **67.46%** |
+| **Prism-MCP (Gemini-2.5-flash + Memory)** | 401 | 361.0 / 401 | **90.02%** | **+20.69pp** | **67.5%** |
 | **Gemini-3.1-pro-preview (Baseline)** | 401 | 272.0 / 401 | **67.83%** | — | — |
-| **Prism-MCP (Gemini-3.1-pro + Memory)** | 401 | 382.0 / 401 | **95.26%** | **+27.43%** | **85.27%** |
+| **Prism-MCP (Gemini-3.1-pro + Memory)** | 401 | 382.0 / 401 | **95.26%** | **+27.43pp** | **85.3%** |
+| **Gemini-3.5-flash (Baseline)** | 401 | 237.0 / 401 | **59.10%** | — | — |
+| **Prism-MCP (Gemini-3.5-flash + Memory)** | 401 | 388.0 / 401 | **96.76%** | **+37.66pp** | **92.1%** |
+| **Claude Sonnet 4.6 (Baseline)** | 401 | 290.0 / 401 | **72.32%** | — | — |
+| **Prism-MCP (Claude Sonnet 4.6 + Memory)** | 401 | 357.0 / 401 | **89.03%** | **+16.71pp** | **60.4%** |
 
 **Key Takeaways**:
-* **Pure attention limits**: Larger raw frontier models (Gemini 3.1 Pro baseline at **67.83%**) suffer from attention dilution (the "needle in a haystack" problem) when parsing massive multi-day transcripts directly in active context.
-* **Semantic database synergy**: Equipping a model with Prism-MCP's structured semantic memory retrieval yields state-of-the-art performance (**95.26%** for Gemini 3.1 Pro + Memory), proving that structured semantic recall is far more accurate than raw model scaling alone.
+* **Pure attention limits**: Even the strongest frontier model tested — Claude Sonnet 4.6 at **72.32%** — misses over a quarter of cognitive memory cues without external memory. Gemini 3.5 Flash baseline sits at **59.10%**. Both suffer from attention dilution when parsing massive multi-day transcripts directly in active context.
+* **Prism lifts every model**: Prism-MCP yields large gains regardless of base model — from +16.71pp (Claude) to +37.66pp (Gemini 3.5 Flash). Even Claude's stronger native recall benefits from structured retrieval, jumping from 72.32% to **89.03%**.
+* **Best overall**: Prism-MCP + Gemini 3.5 Flash achieves the highest score (**96.76%**), eliminating 92.1% of baseline errors. This makes the cheapest model + Prism more accurate than the most expensive model alone.
+* **Claude vs Gemini (raw)**: Claude Sonnet 4.6 outperforms all Gemini baselines by a wide margin (+13.22pp over Flash 3.5, +4.49pp over Pro 3.1), confirming stronger native long-context recall.
 
 <details>
 <summary>🔍 View Test Case Schema & Sample</summary>
 
-A representative test sample from the [unified_cognitive_only.json](file:///tmp/Locomo-Plus/data/unified_cognitive_only.json) ([GitHub source](https://github.com/dcostenco/Locomo-Plus/blob/main/data/unified_cognitive_only.json)) dataset contains a multi-turn chat history with a memory "needle" placed days prior, followed by a cued dialogue prompt:
+A representative test sample from the `unified_cognitive_only.json` ([GitHub source](https://github.com/dcostenco/Locomo-Plus/blob/main/data/unified_cognitive_only.json)) dataset contains a multi-turn chat history with a memory "needle" placed days prior, followed by a cued dialogue prompt:
 
 ```json
 {
@@ -406,7 +424,7 @@ When evaluated:
 <details>
 <summary>💻 View How to Reproduce Publicly (Test Source & Guide)</summary>
 
-To run and review the evaluation suite on your local setup using the benchmark runner scripts ([evaluate_qa.py](file:///tmp/Locomo-Plus/evaluation_framework/task_eval/evaluate_qa.py) and [llm_as_judge.py](file:///tmp/Locomo-Plus/evaluation_framework/task_eval/llm_as_judge.py)):
+To run and review the evaluation suite on your local setup using the benchmark runner scripts (`evaluate_qa.py` and `llm_as_judge.py`):
 
 ```bash
 # 1. Clone the LoCoMo-Plus evaluation codebase
@@ -431,7 +449,16 @@ PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/evaluate_qa.p
   --backend call_prism \
   --concurrency 1
 
-# 4. Grade results using the LLM-as-a-Judge script
+# 4. Run Claude Sonnet 4.6 Baseline Evaluation (concurrency 3, rate-limit safe)
+export ANTHROPIC_API_KEY="your-api-key"
+PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/evaluate_qa.py \
+  --data-file data/unified_cognitive_only.json \
+  --out-file output/claude_sonnet46_pred.json \
+  --model claude-sonnet-4-6 \
+  --backend call_claude \
+  --concurrency 3
+
+# 5. Grade results using the LLM-as-a-Judge script
 PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/llm_as_judge.py \
   --input-file output/prism_gemini_3.1_pro_pred.json \
   --out-file output/prism_gemini_3.1_pro_judged.json \

package/dist/server.js

@@ -104,6 +104,8 @@ SESSION_SAVE_EXPERIENCE_TOOL, KNOWLEDGE_UPVOTE_TOOL, KNOWLEDGE_DOWNVOTE_TOOL,
 SESSION_BACKFILL_LINKS_TOOL, SESSION_SYNTHESIZE_EDGES_TOOL, SESSION_COGNITIVE_ROUTE_TOOL, 
 // v7.1: Task Router
 SESSION_TASK_ROUTE_TOOL, 
+// Session Drift Detection
+SESSION_DETECT_DRIFT_TOOL, 
 // 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
@@ -134,6 +136,8 @@ MAINTENANCE_VACUUM_TOOL, maintenanceVacuumHandler,
 AGENT_REGISTRY_TOOLS, agentRegisterHandler, agentHeartbeatHandler, agentListTeamHandler, 
 // v7.1: Task Router
 sessionTaskRouteHandler, 
+// Session Drift Detection
+sessionDetectDriftHandler, 
 // v7.3: Dark Factory Pipeline tools
 SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL, sessionStartPipelineHandler, sessionCheckPipelineStatusHandler, sessionAbortPipelineHandler, 
 // v12: Handler implementations
@@ -225,6 +229,7 @@ function buildSessionMemoryTools(autoloadList) {
         SESSION_BACKFILL_LINKS_TOOL, // session_backfill_links — retroactive graph edge creation
         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)
         // ─── v6.1: Storage Hygiene tool ───
         MAINTENANCE_VACUUM_TOOL, // maintenance_vacuum — reclaim SQLite disk space post-purge
         // ─── v12.1: Developer Onboarding & Framework Bridge ───
@@ -881,6 +886,12 @@ export function createServer() {
                             throw new Error("Task router not enabled. Enable it in the dashboard or set PRISM_TASK_ROUTER_ENABLED=true.");
                         result = await sessionTaskRouteHandler(args);
                         break;
+                    // ─── Session Drift Detection ───
+                    case "session_detect_drift":
+                        if (!SESSION_MEMORY_ENABLED)
+                            throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
+                        result = await sessionDetectDriftHandler(args);
+                        break;
                     // ─── v7.3: Dark Factory Pipeline Tools ───
                     case "session_start_pipeline":
                         if (!SESSION_MEMORY_ENABLED)

package/dist/storage/synalux.js

@@ -346,6 +346,22 @@ export class SynaluxStorage extends SupabaseStorage {
             };
         }
     }
+    /**
+     * Detect semantic drift between the session goal and recent ledger entries.
+     * Delegates embedding + detection to the Synalux portal (source of truth for
+     * the HRR/GloVe/cosine stack). Prism-mcp never does NLP directly.
+     */
+    async detectDrift(project, goal, windowHours, minDirectionalRatio, extraParams) {
+        const body = { action: "detect_drift", project, goal };
+        if (typeof windowHours === "number")
+            body.window_hours = windowHours;
+        if (typeof minDirectionalRatio === "number")
+            body.min_directional_ratio = minDirectionalRatio;
+        if (extraParams)
+            Object.assign(body, extraParams);
+        const result = await this.portalPost("/api/v1/prism/memory", body);
+        return result;
+    }
     /**
      * Fetch skill content from Synalux portal (paid-tier single source of truth).
      * Returns a map of { skillName → SKILL.md content } for all names that exist.

package/dist/tools/index.js

@@ -54,6 +54,9 @@ export { SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSIO
 export { sessionStartPipelineHandler, sessionCheckPipelineStatusHandler, sessionAbortPipelineHandler, } from "./pipelineHandlers.js";
 // ── v12 Tool Handlers (Developer Onboarding & Enterprise Observability) ──
 export { onboardingWizardHandler, extractEntitiesHandler, apiAnalyticsHandler, backupDatabaseHandler, configureNotificationsHandler, queryMemoryNaturalHandler, } from "./v12Handlers.js";
+// ── Session Drift Detection ──
+export { SESSION_DETECT_DRIFT_TOOL, isSessionDetectDriftArgs } from "./sessionMemoryDefinitions.js";
+export { sessionDetectDriftHandler } from "./sessionDriftHandler.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/sessionDriftHandler.js

@@ -0,0 +1,62 @@
+/**
+ * session_detect_drift — MCP Tool Handler
+ *
+ * Thin-client dispatcher: validates args, delegates to the Synalux portal
+ * (POST /api/v1/prism/memory action=detect_drift) which owns the embedding
+ * + detection logic, and returns the structured result.
+ *
+ * Prism-mcp never does NLP or embedding here — that lives in synalux-private.
+ */
+import { isSessionDetectDriftArgs } from "./sessionMemoryDefinitions.js";
+import { getStorage } from "../storage/index.js";
+import { debugLog } from "../utils/logger.js";
+export async function sessionDetectDriftHandler(args) {
+    if (!isSessionDetectDriftArgs(args)) {
+        return {
+            content: [{ type: "text", text: "Invalid arguments for session_detect_drift. Required: project (string), goal (string). Optional: window_hours (number), min_directional_ratio (number)." }],
+            isError: true,
+        };
+    }
+    try {
+        const storage = await getStorage();
+        // SynaluxStorage exposes detectDrift(); SqliteStorage falls through to
+        // an error because it has no embedding stack. Free-tier users without
+        // portal access receive a clear upgrade message.
+        if (typeof storage.detectDrift !== "function") {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            status: "error",
+                            error: "session_detect_drift requires cloud memory (Standard plan or higher). Set SUPABASE_URL and SUPABASE_KEY to enable.",
+                            upgrade_url: "/pricing",
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        // Build extra params for domain-specific signals
+        const extra = {};
+        if (args.domain)
+            extra.domain = args.domain;
+        if (args.behavior_functions)
+            extra.behavior_functions = args.behavior_functions;
+        if (args.contraindications)
+            extra.contraindications = args.contraindications;
+        if (args.client_descriptors)
+            extra.client_descriptors = args.client_descriptors;
+        if (args.assessment_type)
+            extra.assessment_type = args.assessment_type;
+        const result = await storage.detectDrift(args.project, args.goal, args.window_hours, args.min_directional_ratio, Object.keys(extra).length > 0 ? extra : undefined);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (err) {
+        debugLog(`[session_detect_drift] Failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            content: [{ type: "text", text: `Error running drift detection: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/sessionMemoryDefinitions.js

@@ -1664,3 +1664,89 @@ export function isQueryMemoryNaturalArgs(args) {
         return false;
     return true;
 }
+// ─── Session Detect Drift ──────────────────────────────────────────
+export const SESSION_DETECT_DRIFT_TOOL = {
+    name: "session_detect_drift",
+    description: "Detect whether the current agent session has semantically drifted from its " +
+        "original goal. Scores recent ledger entries against the goal using synalux's " +
+        "HRR embedding stack (GloVe → Gemini/Voyage → cosine similarity), then runs " +
+        "the rolling-window drift detector algorithm.\n\n" +
+        "**Triggers:**\n" +
+        "- `goal-drift` — cumulative alignment loss is high and monotonic (not random tangents)\n" +
+        "- `context-collapse` — average output quality has dropped below floor\n\n" +
+        "**Pre-warning:**\n" +
+        "- `quality-degrading` — quality slope steeply negative before collapse\n\n" +
+        "**Returns:** drifted, reason, warning, drift_score (0..1), goal_alignment, " +
+        "quality_avg, sample_count, adaptive_threshold, recommendation.\n\n" +
+        "Use alongside GATE 5 (60-minute drift check): call this tool instead of " +
+        "session_cognitive_route for goal-alignment drift detection.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project identifier. Must match the project used in session_save_ledger.",
+            },
+            goal: {
+                type: "string",
+                description: "The original session goal — the task you started this session to accomplish. " +
+                    "Used as the semantic reference vector. Be specific: 'implement drift detection for prism-mcp' " +
+                    "is better than 'work on prism'.",
+            },
+            window_hours: {
+                type: "number",
+                description: "How many hours of ledger history to evaluate. Default 1. Range 0.083–24 (5 min to 24 h).",
+            },
+            min_directional_ratio: {
+                type: "number",
+                description: "Directional ratio floor for the tremor filter (0..1). " +
+                    "Random topic tangents that return to the goal are suppressed below this threshold. " +
+                    "Default 0.2. Set to 0 to disable filter.",
+            },
+            domain: {
+                type: "string",
+                enum: ["coder", "bcba", "aac"],
+                description: "Optional domain for domain-specific drift signals. " +
+                    "'coder' adds file_entropy, summary_vagueness, test_coverage_ratio, trajectory_divergence. " +
+                    "'bcba' adds clinical_specificity, function_aligned, contraindication_safe (requires behavior_functions, contraindications, client_descriptors params). " +
+                    "'aac' is reserved for future AAC prediction drift (use the AAC-specific endpoint instead).",
+            },
+            behavior_functions: {
+                type: "array",
+                items: { type: "string" },
+                description: "BCBA domain only: identified behavior functions for this client (e.g. ['escape-maintained', 'attention-maintained']).",
+            },
+            contraindications: {
+                type: "array",
+                items: { type: "string" },
+                description: "BCBA domain only: known medical conditions (e.g. ['epilepsy', 'pica']).",
+            },
+            client_descriptors: {
+                type: "array",
+                items: { type: "string" },
+                description: "BCBA domain only: client-specific terms to check for specificity (e.g. ['7-year-old', 'aggression at transitions']).",
+            },
+            assessment_type: {
+                type: "string",
+                description: "BCBA domain only: assessment instrument name (e.g. 'vb-mapp', 'vineland', 'ablls-r').",
+            },
+        },
+        required: ["project", "goal"],
+    },
+};
+export function isSessionDetectDriftArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    if (typeof a.project !== "string" || !a.project.trim())
+        return false;
+    if (typeof a.goal !== "string" || !a.goal.trim())
+        return false;
+    if (a.window_hours !== undefined && typeof a.window_hours !== "number")
+        return false;
+    if (a.min_directional_ratio !== undefined && typeof a.min_directional_ratio !== "number")
+        return false;
+    if (a.domain !== undefined && !["coder", "bcba", "aac"].includes(a.domain))
+        return false;
+    return true;
+}

package/dist/utils/ddLogger.js

@@ -1,15 +1,16 @@
 /**
- * Datadog Server-Side Logger
+ * Telemetry Logger — Prism MCP Server
  *
- * Sends structured logs to Datadog HTTP Logs API.
- * No agent needed — direct HTTPS POST to intake.
+ * Sends structured events to Synalux portal (/api/v1/telemetry)
+ * which stores in Supabase with 15-day retention.
  *
- * Env: DD_API_KEY, DD_SITE (default datadoghq.com)
+ * Falls back to Datadog HTTP Logs if DD_API_KEY is set.
+ * Env: PRISM_SYNALUX_BASE_URL (default https://synalux.ai)
  */
+const SYNALUX_BASE = process.env.PRISM_SYNALUX_BASE_URL || "https://synalux.ai";
 const DD_API_KEY = process.env.DD_API_KEY || "";
 const DD_SITE = process.env.DD_SITE || "datadoghq.com";
 const SERVICE = "prism-mcp";
-const INTAKE_URL = `https://http-intake.logs.${DD_SITE}/api/v2/logs`;
 const queue = [];
 let flushTimer = null;
 const FLUSH_INTERVAL_MS = 5_000;
@@ -21,29 +22,46 @@ function scheduleFlush() {
 }
 async function flush() {
     flushTimer = null;
-    if (queue.length === 0 || !DD_API_KEY)
+    if (queue.length === 0)
         return;
     const batch = queue.splice(0, MAX_BATCH);
+    // Primary: Synalux portal → Supabase (always available)
     try {
-        await fetch(INTAKE_URL, {
+        await fetch(`${SYNALUX_BASE}/api/v1/telemetry`, {
             method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "DD-API-KEY": DD_API_KEY,
-            },
-            body: JSON.stringify(batch),
+            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 app if DD is unreachable
+        // Silent — don't crash the MCP server
+    }
+    // Secondary: Datadog Logs (if API key is set AND Logs product is enabled)
+    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),
+                signal: AbortSignal.timeout(5_000),
+            });
+        }
+        catch {
+            // Silent
+        }
     }
     if (queue.length > 0)
         scheduleFlush();
 }
 export function ddLog(level, message, context) {
-    if (!DD_API_KEY)
-        return;
     queue.push({
         ddsource: "nodejs",
         ddtags: `env:${process.env.NODE_ENV || "development"},service:${SERVICE}`,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "prism-mcp-server",
-  "version": "16.2.0",
+  "version": "17.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, 54 Agent Skills, Zero-Search HDC/HRR retrieval, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder:7b / 14b 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, 54 Agent Skills, 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:7b / 14b open-weights LLM fleet.",
   "module": "index.ts",
   "type": "module",
   "main": "dist/server.js",