prism-mcp-server 16.1.1 → 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.
 
@@ -229,6 +241,51 @@ That's it. Open Claude / Cursor and your AI now has memory.
 
 More setup details in [`docs/SETUP_GEMINI.md`](docs/SETUP_GEMINI.md).
 
+### Monitoring & Observability *(new in v16.2)*
+
+Built-in Datadog integration — every tool call is logged with tool name, project, and latency. Zero config for self-hosted users (logs to stdout); set `DD_API_KEY` to send structured logs to Datadog HTTP intake.
+
+```bash
+# Enable Datadog logging (optional)
+export DD_API_KEY=your_datadog_api_key
+
+# Enable OpenTelemetry tracing (optional — works with Jaeger, Zipkin, Datadog, Grafana Tempo)
+export PRISM_OTEL_ENABLED=true
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+```
+
+**What's tracked automatically:**
+- `mcp.tool.success` — tool name, project, duration (ms) on every successful call
+- `mcp.tool.error` — tool name, error message, stack trace on failures
+- OpenTelemetry spans with `tool.name` and `project` attributes on all 50 tool handlers
+
+| Dashboard | What it tracks |
+|-----------|---------------|
+| [Prism MCP — Server Analytics](https://app.datadoghq.com/dashboard/tdm-92f-myh/prism-mcp--server-analytics) | Tool call volume, latency per tool (avg/p95), errors by tool, project activity, knowledge search/ingest, session memory ops |
+
+### In-app analytics for paid users *(new in v16.2)*
+
+Paid Synalux subscribers get a built-in analytics dashboard at `/app/memory-analytics`:
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Analytics                              [standard] plan │
+├─────────────────────────────────────────────────────────┤
+│  📝 Sessions: 147  🔄 Handoffs: 23  📚 Knowledge: 89  │
+│  📁 Projects: 5    💾 Memory: 42 KB                    │
+├─────────────────────────────────────────────────────────┤
+│  Today's Usage    🧠 47/200  🔎 12/50  💬 85/200       │
+├─────────────────────────────────────────────────────────┤
+│  30-Day Trend     ▂▃▅▇▆▄▃▅▆▇█▇▅▃▂▃▅▆▇▅▃▂▁▂▃▅▇▆▅▃    │
+├─────────────────────────────────────────────────────────┤
+│  Top Projects     prism-mcp (45) · portal (32) · ...   │
+│  Compaction       3 entries > 5KB — run compact_ledger  │
+└─────────────────────────────────────────────────────────┘
+```
+
+- **Free tier**: paywall with upgrade CTA
+- **Standard+**: session counts, handoffs, knowledge entries, daily quotas with tier limits, 30-day activity trend, project breakdown, compaction candidates
+
 ---
 
 ## How AI agents use it
@@ -319,6 +376,98 @@ 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) | [`dcostenco/Locomo-Plus`](https://github.com/dcostenco/Locomo-Plus) | Long-context dialogue coherence and historical memory retention |
+
+### Cognitive Dialogue Memory (LoCoMo-Plus Benchmark)
+
+LoCoMo-Plus is a long-context, multi-day dialogue benchmark designed to test an AI agent's memory retention, context awareness, and ability to coherently reference historical dialogue evidence.
+
+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 | 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.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.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**: 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` ([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
+{
+  "category": "Cognitive",
+  "input_prompt": "Caroline said, \"...\"\nMelanie said, \"...\"",
+  "trigger": "Melanie said, \"Hey, Caroline! Nice to hear from you! Love the necklace, any special meaning to it?\"",
+  "evidence": "Swedish grandmother's necklace was gifted to Caroline",
+  "answer": "Yes, this necklace was a gift from my grandmother in my home country, Sweden."
+}
+```
+
+When evaluated:
+* **Baseline models** without memory frequently output a generic guess (e.g., "Thanks, it was a gift from a friend") or fail to reference the Sweden/grandmother relationship.
+* **Prism-MCP** automatically embeds the prior turns, stores them in SQLite, and when cued, retrieves the precise "Swedish grandmother" evidence turn via semantic vectors to inject it into active context.
+</details>
+
+<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` and `llm_as_judge.py`):
+
+```bash
+# 1. Clone the LoCoMo-Plus evaluation codebase
+git clone https://github.com/dcostenco/Locomo-Plus /tmp/Locomo-Plus
+cd /tmp/Locomo-Plus
+
+# 2. Run Baseline Gemini 3.1 Pro Evaluation (concurrency 5)
+export GOOGLE_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/gemini_3.1_pro_pred.json \
+  --model gemini-3.1-pro-preview \
+  --backend call_gemini \
+  --concurrency 5
+
+# 3. Run Prism-MCP powered by Gemini 3.1 Pro Evaluation (concurrency 1 to guard SQLite locks)
+export PRISM_TEXT_MODEL=gemini-3.1-pro-preview
+PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/evaluate_qa.py \
+  --data-file data/unified_cognitive_only.json \
+  --out-file output/prism_gemini_3.1_pro_pred.json \
+  --model gemini-3.1-pro-preview \
+  --backend call_prism \
+  --concurrency 1
+
+# 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 \
+  --model gemini-2.5-flash \
+  --backend call_gemini \
+  --concurrency 5 \
+  --summary-file output/prism_gemini_3.1_pro_summary.json
+```
+</details>
 
 ### Models on HuggingFace
 

package/dist/server.js

@@ -77,6 +77,7 @@ import { getSettingSync, initConfigStorage } from "./storage/configStorage.js";
 import { sanitizeMcpOutput } from "./utils/sanitizer.js";
 import { getTracer, initTelemetry } from "./utils/telemetry.js";
 import { context as otelContext, trace, SpanStatusCode } from "@opentelemetry/api";
+import { ddInfo, ddError as ddLogError } from "./utils/ddLogger.js";
 // ─── Import Tool Definitions (schemas) and Handlers (implementations) ─────
 import { WEB_SEARCH_TOOL, BRAVE_WEB_SEARCH_CODE_MODE_TOOL, LOCAL_SEARCH_TOOL, BRAVE_LOCAL_SEARCH_CODE_MODE_TOOL, CODE_MODE_TRANSFORM_TOOL, BRAVE_ANSWERS_TOOL, RESEARCH_PAPER_ANALYSIS_TOOL, webSearchHandler, braveWebSearchCodeModeHandler, localSearchHandler, braveLocalSearchCodeModeHandler, codeModeTransformHandler, braveAnswersHandler, researchPaperAnalysisHandler, } from "./tools/index.js";
 // Session memory tools — only used if Supabase is configured
@@ -103,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
@@ -133,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
@@ -224,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 ───
@@ -672,6 +678,7 @@ export function createServer() {
         // through await chains — including fire-and-forget workers launched
         // within the handler body (e.g. imageCaptioner, embeddings backfill).
         return otelContext.with(trace.setSpan(otelContext.active(), rootSpan), async () => {
+            const _ddStart = Date.now();
             try {
                 if (!args) {
                     throw new Error("No arguments provided");
@@ -879,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)
@@ -945,6 +958,7 @@ export function createServer() {
                         };
                 }
                 rootSpan.setStatus({ code: SpanStatusCode.OK });
+                ddInfo("mcp.tool.success", { tool: name, project: args?.project, durationMs: Date.now() - _ddStart });
                 // ═══ v5.3: Hivemind Watchdog Alert Injection (Telepathy) ═══
                 // CRITICAL: Append alerts DIRECTLY to tool response content
                 // so the LLM actually reads them. sendLoggingMessage goes to
@@ -985,6 +999,7 @@ export function createServer() {
             }
             catch (error) {
                 console.error(`Error in tool handler: ${error instanceof Error ? error.message : String(error)}`);
+                ddLogError("mcp.tool.error", error instanceof Error ? error : undefined, { tool: name, project: args?.project, durationMs: Date.now() - _ddStart });
                 rootSpan.recordException(error instanceof Error ? error : new Error(String(error)));
                 rootSpan.setStatus({
                     code: SpanStatusCode.ERROR,

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/dist/utils/llm/adapters/gemini.js

@@ -37,7 +37,7 @@ import { debugLog } from "../../logger.js";
 // ─── Model Constants ──────────────────────────────────────────────────────────
 // Defined as constants (not hardcoded strings) so external reviewers can see
 // all model choices at a glance, and future changes only need one edit.
-const TEXT_MODEL = "gemini-2.5-flash"; // chat/instruction-following model
+const TEXT_MODEL = process.env.PRISM_TEXT_MODEL || "gemini-2.5-flash"; // chat/instruction-following model
 const EMBEDDING_MODEL = "gemini-embedding-001"; // vector embedding model (MRL-enabled)
 const EMBEDDING_DIMS = 768; // fixed output dims — must match DB schema
 // ─── Embedding Truncation Constants ──────────────────────────────────────────

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "prism-mcp-server",
-  "version": "16.1.1",
+  "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",