prism-mcp-server 19.3.1 → 20.0.0

package/README.md

@@ -4,7 +4,7 @@
 
 [![npm](https://img.shields.io/npm/v/prism-mcp-server?color=cb0000&label=npm)](https://www.npmjs.com/package/prism-mcp-server)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-00ADD8)](https://github.com/modelcontextprotocol/servers)
-[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE)
 [![Models on HuggingFace](https://img.shields.io/badge/🤗-prism--coder-yellow)](https://huggingface.co/dcostenco)
 
 <p align="center">
@@ -18,6 +18,25 @@ A paid subscription adds cloud sync, higher model tiers, and team features throu
 
 ---
 
+## What's New in v20
+
+### License: AGPL-3.0 → Apache-2.0
+Prism MCP is now Apache-2.0. The thin-client architecture means all proprietary value (skill resolution, tier gating, billing, cloud inference) lives server-side — the open client carries no moat to protect. Apache-2.0 removes the enterprise adoption friction that AGPL caused.
+
+### Thin Client Architecture
+Skill routing, budget management, and content resolution have moved server-side to the Synalux portal. The MCP client is now a thin API caller — simpler, smaller, and portable across any host (Claude Code, Gemini, Cursor, autonomous scripts). Offline fallback reads the last successful response from local SQLite.
+
+### Clean-Room Voyage AI Adapter
+The Voyage AI embedding adapter was independently reimplemented from the [Voyage API docs](https://docs.voyageai.com/reference/embeddings-api) to ensure 100% project-owned copyright. Default model updated to `voyage-3.5`. See [PROVENANCE.md](./PROVENANCE.md) for details.
+
+### Server-Side Drift Detection
+Session drift detection (GATE 5) no longer requires Claude Code hooks. The timer runs server-side per conversation, piggybacked on every MCP tool response. Works for any host.
+
+### CLA Requirement
+External contributions now require signing the [Individual CLA](./CLA.md). The CLA check is merge-blocking on the `main` branch.
+
+---
+
 ## Quickstart
 
 The free tier needs no account, no API key, and no cloud. Add the server to your MCP client:
@@ -85,7 +104,9 @@ Every `prism_infer` call tracks which model handled it (local Ollama vs cloud) a
 ```
 📊 Inference Metrics (this session):
   Total calls: 12 — Local: 10 (83%) | Cloud: 2 (17%)
-  Tokens: 8,420 in + 3,150 out = 11,570 total
+  Prompt tokens: 7,840 evaluated / 8,420 submitted est.
+  Completion tokens: 3,150
+  Cloud tokens saved (est.): 11,570 — token volume handled locally instead of cloud
   Avg latency: 1,240ms
   By model:
     prism-coder:27b: 6 calls, 7,200 tokens, avg 1,800ms
@@ -93,6 +114,8 @@ Every `prism_infer` call tracks which model handled it (local Ollama vs cloud) a
     synalux-27b: 2 calls, 1,500 tokens, avg 1,100ms
 ```
 
+**Cloud tokens saved** is the honest routing metric — it accrues only when local Ollama handles a call that would otherwise have gone to Claude or the Synalux portal. A compact version appears inline after every 5th `prism_infer` call: `📊 local 10 (83%) · cloud 2 (17%) · ~11,570 tok · avg 1,240ms · 11,570 cloud tok saved`.
+
 Local calls use actual Ollama token counts (`prompt_eval_count` / `eval_count` from Ollama); cloud calls use char/4 estimates. Metrics are tracked locally — no portal dependency, no env vars, works offline. Per-call data is also forwarded to the Synalux portal as best-effort analytics (independent of the display).
 
 ### Session Drift Detection
@@ -619,15 +642,30 @@ It reads `~/.prism-mcp/data.db` and POSTs entries to the portal. Ledger entries
 
 ---
 
-## License
+## License & Tiers
+
+- **This repository (the Prism MCP client)** is licensed under [Apache-2.0](./LICENSE).
+- **Free tier**: run Prism MCP locally against your own machine. No account required.
+- **Paid tiers**: cloud features (hosted inference cascade, cross-device memory,
+  team features) are provided by the Synalux cloud service and governed by the
+  Synalux Terms of Service — they are not part of this repository or its license.
+- Contributions require signing the [CLA](./CLA.md).
+- "Prism" and "Synalux" are trade names of Synalux LLC; the Apache license does
+  not grant trademark rights (see §6 of the license).
+
+### License change (v20)
+
+As of this release, prism-mcp is relicensed from AGPL-3.0 to Apache-2.0.
+Prior versions remain under AGPL-3.0. Existing forks retain all rights
+received under the original license.
 
 | Product | License |
 |---|---|
-| **prism-mcp-server** (this repo) | [AGPL-3.0](LICENSE) |
+| **prism-mcp-server** (this repo) | [Apache-2.0](LICENSE) |
 | **VS Code extension** (synalux-ai.synalux) | BSL-1.1 |
 | **Web IDE** (synalux.ai/coder) | Synalux Terms of Service |
-| **Prism AAC** | AGPL-3.0 |
+| **Prism AAC** | Apache-2.0 |
 
-The AGPL-3.0 license covers the MCP server and its source code. The VS Code extension and Web IDE are separate products with their own licenses. Commercial hosted/managed deployment of the MCP server is available via the Synalux subscription.
+This repository is licensed under Apache-2.0. Cloud features (hosted inference, cross-device memory, team features) are provided by the Synalux cloud service under separate terms.
 
 © 2026 Synalux, LLC.

package/dist/config.js

@@ -15,9 +15,8 @@ import { fileURLToPath } from "node:url";
  *   SUPABASE_KEY           — (optional) Your Supabase anon/service key. Enables session memory tools.
  *   PRISM_USER_ID          — (optional) Unique tenant ID for multi-user Supabase instances.
  *                            Defaults to "default". Set per-user in Claude Desktop config.
- *   VOYAGE_API_KEY         — (optional) API key for Voyage AI embeddings. Enables embedding_provider=voyage.
- *                            Voyage AI is the embedding provider recommended by Anthropic for use with
- *                            Claude. Get a free key at https://dash.voyageai.com.
+ *   VOYAGE_API_KEY         — (optional) Voyage AI API key for embeddings.
+ *                            Set embedding_provider=voyage to use. https://dash.voyageai.com
  *
  * If a required key is missing, the process exits immediately.
  * If an optional key is missing, a warning is logged but the server continues
@@ -64,14 +63,9 @@ export const SEMANTIC_SCHOLAR_API_KEY = process.env.SEMANTIC_SCHOLAR_API_KEY;
 if (!BRAVE_ANSWERS_API_KEY && process.env.PRISM_DEBUG_LOGGING === "true") {
     console.error("Warning: BRAVE_ANSWERS_API_KEY environment variable is missing. Brave Answers tool will be unavailable.");
 }
-// ─── Optional: Voyage AI API Key ──────────────────────────────
-// Used when embedding_provider = "voyage" in the dashboard.
-// Voyage AI is the embedding provider recommended by Anthropic for use
-// alongside Claude. voyage-3 supports 768-dim output via MRL truncation,
-// matching Prism's storage schema for zero-migration drop-in replacement.
-// Without this, VoyageAdapter construction will throw at server start if
-// embedding_provider=voyage is selected.
-export const VOYAGE_API_KEY = process.env.VOYAGE_API_KEY;
+// ─── Optional: Voyage AI Embeddings ──────────────────────────
+// Set embedding_provider=voyage to enable. Requires VOYAGE_API_KEY.
+export const VOYAGE_API_KEY = process.env.VOYAGE_API_KEY; // embedding_provider=voyage
 // ─── Optional: Google Search (Scholar Pipeline Fallback) ──────
 // Used when Brave or Tavily keys are missing.
 // Requires: Google Custom Search API Key + Search Engine ID (CX).

package/dist/scholar/webScholar.js

@@ -1,4 +1,4 @@
-import { BRAVE_API_KEY, FIRECRAWL_API_KEY, GOOGLE_SEARCH_API_KEY, GOOGLE_SEARCH_CX, SEMANTIC_SCHOLAR_API_KEY, PRISM_SCHOLAR_MAX_ARTICLES_PER_RUN, PRISM_USER_ID, PRISM_SCHOLAR_TOPICS, PRISM_ENABLE_HIVEMIND } from "../config.js";
+import { BRAVE_API_KEY, FIRECRAWL_API_KEY, GOOGLE_SEARCH_API_KEY, GOOGLE_SEARCH_CX, SEMANTIC_SCHOLAR_API_KEY, PRISM_SCHOLAR_MAX_ARTICLES_PER_RUN, PRISM_USER_ID, PRISM_SCHOLAR_TOPICS, PRISM_ENABLE_HIVEMIND, } from "../config.js";
 import { getStorage } from "../storage/index.js";
 import { debugLog } from "../utils/logger.js";
 import { getLLMProvider } from "../utils/llm/factory.js";

package/dist/server.js

@@ -729,6 +729,14 @@ export function createServer() {
                         if (!SESSION_MEMORY_ENABLED)
                             throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
                         result = await sessionSaveLedgerHandler(args);
+                        // GATE 5: Reset drift timer — save_ledger counts as a drift checkpoint
+                        {
+                            const cid = args?.conversation_id;
+                            if (cid) {
+                                const { noteDriftCheck } = await import("./session/sessionContext.js");
+                                noteDriftCheck(cid);
+                            }
+                        }
                         break;
                     case "session_save_handoff":
                         if (!SESSION_MEMORY_ENABLED)
@@ -902,6 +910,14 @@ export function createServer() {
                         if (!SESSION_MEMORY_ENABLED)
                             throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
                         result = await sessionDetectDriftHandler(args);
+                        // GATE 5: Reset drift timer — detect_drift is the canonical check
+                        {
+                            const cid = args?.conversation_id;
+                            if (cid) {
+                                const { noteDriftCheck } = await import("./session/sessionContext.js");
+                                noteDriftCheck(cid);
+                            }
+                        }
                         break;
                     case "verify_behavior":
                         if (!isVerifyBehaviorArgs(args))
@@ -1008,6 +1024,24 @@ export function createServer() {
                         }
                     }
                 }
+                // ═══ GATE 5: Server-Side Drift Timer Injection ═══
+                // Piggyback on every prism-mcp tool response: if the session is 60+
+                // minutes old and hasn't run session_detect_drift in the last 60 min,
+                // append a mandatory reminder. This replaces the guard_on_submit.py
+                // hook dependency — works on any host, not just Claude Code.
+                if (result && !result.isError && Array.isArray(result.content)) {
+                    const convId = args?.conversation_id;
+                    if (convId) {
+                        try {
+                            const { getDriftReminder } = await import("./session/sessionContext.js");
+                            const reminder = getDriftReminder(convId);
+                            if (reminder) {
+                                result.content.push({ type: "text", text: reminder });
+                            }
+                        }
+                        catch { /* getDriftReminder is best-effort — never block tool responses */ }
+                    }
+                }
                 // Sanitize all text content returning from MCP tools to prevent prompt injection
                 if (result && Array.isArray(result.content)) {
                     result.content.forEach((c) => {

package/dist/session/sessionContext.js

@@ -1,37 +1,28 @@
 /**
- * src/session/sessionContext.ts
+ * Session state tracking — connection-scoped, in-process.
  *
- * Server-side session state, keyed on conversation_id (the same id threaded
- * through session_load_context / session_save_ledger / prism_infer).
+ * This is NOT business logic — it's MCP connection lifecycle state.
+ * Business logic (skill routing, budget tranching, content resolution)
+ * lives in the synalux portal at /api/v1/prism/skills.
  *
- * WHY THIS EXISTS
- * ---------------
- * On Claude Code, "call session_load_context first" was enforced by the
- * guard_on_submit hook injecting a MANDATORY STARTUP reminder, and by
- * mark_loaded.py flipping a pending flag. Neither mechanism runs on a
- * non-Claude host (Gemini, autonomous script, cron job).
+ * What stays here (connection-scoped, cannot be portal-side):
+ *   markContextLoaded / requireContextLoaded — write-gate for session tools
+ *   noteInferenceForSession — telemetry counter
+ *   drift timer — connection-scoped GATE 5 enforcement
  *
- * This module moves that state server-side so any host that calls
- * session_load_context gets its conversation marked as loaded — regardless
- * of whether it ran the hook.
- *
- * TWO DELIBERATE BOUNDARIES
- * -------------------------
- * 1. This is NOT a safety mechanism. prism_infer's input/output safety gates
- *    run unconditionally before and after every model call. A host that never
- *    loads context still cannot reach an un-gated model.
- *
- * 2. requireContextLoaded gates only CORRECTNESS-requiring, project-scoped
- *    actions (save_ledger, save_handoff) — tools that act on a specific project
- *    and produce wrong results if the agent hasn't confirmed its working context.
- *    Do NOT gate prism_infer on this; a host that never loads context must still
- *    be able to run inference (safety is already unconditional there).
- *
- * Fail-closed: an unknown or expired conversation_id → context not loaded.
+ * What moved to portal (business logic):
+ *   Skill routing, budget tranching, content loading, phantom detection,
+ *   prompt-keyword matching, user-local skill loading, context-discovery.
  */
 import { BOUNDARIES_VERSION as CURRENT_BOUNDARIES_VERSION } from "../boundaries/boundaries.js";
 const SESSION_TTL_MS = 6 * 60 * 60 * 1000; // 6 h — conversation-scoped
 const MAX_SESSIONS = 10_000;
+/**
+ * Connection-scoped fallback: remember the last conversation_id seen via
+ * markContextLoaded so that tools which don't carry conversation_id
+ * (e.g. prism_infer) still benefit from drift reminders.
+ */
+let lastSeenConversationId;
 // JS Map preserves insertion order. Touch-on-access (delete + re-insert) keeps
 // the Map ordered LRU-last so eviction can pop the first key in O(1).
 const sessions = new Map();
@@ -88,6 +79,7 @@ export function markContextLoaded(conversationId, project, boundariesVersion) {
     s.contextLoaded = true;
     s.project = project;
     s.boundariesVersion = boundariesVersion;
+    lastSeenConversationId = conversationId;
 }
 /**
  * Soft gate for handlers that need project context to be CORRECT (not safe).
@@ -163,3 +155,70 @@ export function noteInferenceForSession(conversationId, info) {
 export function getSessionState(conversationId) {
     return sessions.get(conversationId) ?? null;
 }
+// ─── GATE 5: Server-Side Drift Timer ────────────────────────
+// These functions track drift detection timing per conversation so the
+// server can inject GATE 5 reminders into tool responses without relying
+// on external hooks (guard_on_submit.py). The server is pull-based — it
+// can only inject when a tool is called, so we piggyback on every
+// prism-mcp tool response when the timer is overdue.
+const DRIFT_CHECK_INTERVAL_MS = 60 * 60 * 1000; // 60 minutes
+/**
+ * Called by sessionLoadContextHandler to mark session start for drift timing.
+ */
+export function noteDriftSessionStart(conversationId) {
+    const s = sessions.get(conversationId);
+    if (!s)
+        return;
+    s.driftSessionStart = Date.now();
+    // Don't set driftLastCheck — the first check should happen 60 min after start
+}
+/**
+ * Called after session_detect_drift or session_save_ledger completes
+ * to reset the drift timer for this conversation.
+ */
+export function noteDriftCheck(conversationId) {
+    const s = sessions.get(conversationId);
+    if (!s)
+        return;
+    s.driftLastCheck = Date.now();
+    touch(conversationId, s);
+}
+/**
+ * Returns a GATE 5 drift reminder string if 60+ minutes have elapsed
+ * since session start AND 60+ minutes since the last drift check.
+ * Returns empty string if no reminder is due or if the session is too
+ * young (< 60 min).
+ *
+ * This is called from the common tool response path in server.ts and
+ * appended to every prism-mcp tool response when overdue.
+ */
+export function getDriftReminder(conversationId) {
+    const effectiveId = conversationId || lastSeenConversationId;
+    if (!effectiveId)
+        return "";
+    const s = sessions.get(effectiveId);
+    if (!s || !s.contextLoaded || !s.driftSessionStart)
+        return "";
+    const now = Date.now();
+    const sessionAge = now - s.driftSessionStart;
+    // Session must be at least 60 minutes old before reminders kick in
+    if (sessionAge < DRIFT_CHECK_INTERVAL_MS)
+        return "";
+    // If a drift check has been done, only remind if 60+ min since last check
+    if (s.driftLastCheck) {
+        const sinceLastCheck = now - s.driftLastCheck;
+        if (sinceLastCheck < DRIFT_CHECK_INTERVAL_MS)
+            return "";
+    }
+    // Drift reminder is overdue
+    const minutesSinceStart = Math.round(sessionAge / 60_000);
+    const minutesSinceCheck = s.driftLastCheck
+        ? Math.round((now - s.driftLastCheck) / 60_000)
+        : minutesSinceStart;
+    return (`\n\n[⏰ GATE 5 — DRIFT CHECK OVERDUE (${minutesSinceCheck} min since last check, session ${minutesSinceStart} min old)]\n` +
+        `Long-session drift protocol requires action NOW:\n` +
+        `1. Call session_save_ledger — snapshot current state\n` +
+        `2. Call session_detect_drift — check drift vs original goals\n` +
+        `3. If major_drift returned: call session_compact_ledger + reload context\n` +
+        `This check is MANDATORY every 60 minutes. Do not skip.`);
+}

package/dist/storage/sqlite.js

@@ -741,6 +741,7 @@ export class SqliteStorage {
         "archived_at", "deleted_at", "is_rollup", "role", "event_type",
         "created_at", "updated_at", "session_date", "importance", "title",
         "agent_name", "last_accessed_at", "confidence_score", "rollup_count",
+        "embedding",
     ]);
     parsePostgRESTFilters(params) {
         const conditions = [];

package/dist/tools/__tests__/ledgerHandlers.test.js

@@ -128,6 +128,9 @@ vi.mock("../../../src/session/sessionContext.js", () => ({
     requireContextLoaded: vi.fn(() => null),
     noteInferenceForSession: vi.fn(),
     getSessionState: vi.fn(() => null),
+    noteDriftSessionStart: vi.fn(),
+    noteDriftCheck: vi.fn(),
+    getDriftReminder: vi.fn(() => ""),
 }));
 // Boundaries — return minimal stubs so load-context tests don't depend on exact text.
 vi.mock("../../../src/boundaries/boundaries.js", () => ({

package/dist/tools/ledgerHandlers.js

@@ -31,7 +31,7 @@ import { getCurrentGitState, getGitDrift } from "../utils/git.js";
 import { getSetting, getAllSettings } from "../storage/configStorage.js";
 import { mergeHandoff, dbToHandoffSchema, sanitizeForMerge } from "../utils/crdtMerge.js";
 import { resolveProject } from "../utils/projectResolver.js";
-import { PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS, SYNALUX_CONFIGURED } from "../config.js";
+import { PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS } from "../config.js";
 import { captureLocalEnvironment } from "../utils/autoCapture.js";
 import { fireCaptionAsync } from "../utils/imageCaptioner.js";
 import { isSessionSaveLedgerArgs, isSessionSaveHandoffArgs, isSessionLoadContextArgs, isMemoryHistoryArgs, isMemoryCheckoutArgs, // v2.2.0: health check type guard
@@ -612,7 +612,7 @@ export async function sessionLoadContextHandler(args) {
     if (getInferenceSnapshot().totalCalls === 0) {
         resetInferenceMetrics();
     }
-    const { project, level = "standard", role, conversation_id: convId } = args;
+    const { project, level = "standard", role, conversation_id: convId, prompt } = args;
     // T6 fix: explicit Number() coercion prevents string "2000" from later concatenating instead of adding
     const _maxTokensArg = Number(args.max_tokens);
     const _maxTokensSetting = parseInt(await getSetting("max_tokens", "0"), 10);
@@ -638,22 +638,32 @@ export async function sessionLoadContextHandler(args) {
     if (!data) {
         let freshSkillBlock = "";
         try {
-            const { resolveSkillsForProject: resolveForFresh } = await import("./skillRouting.js");
-            const freshResolved = await resolveForFresh(project);
-            for (const entry of freshResolved.skills.filter(e => e.protected)) {
-                const content = await getSetting(`skill:${entry.name}`, "");
-                if (!content?.trim())
-                    continue;
-                freshSkillBlock += `\n\n[📜 SKILL: ${entry.name}]\n${content.trim()}`;
+            const { resolveSkills: resolveForFresh } = await import("./skillRouting.js");
+            const freshResolution = await resolveForFresh(project);
+            if (freshResolution.skillBlock) {
+                freshSkillBlock = freshResolution.skillBlock;
+            }
+            // Offline fallback: load protected skills from local DB
+            if (freshResolution.isOffline) {
+                const protectedNames = ['prime-directive', 'evidence-first-protocol', 'behavioral-verifier', 'occam-razor-protocol', 'session-drift-detection', 'pre-commit-protocol', 'pre-push-audit', 'implementation-integrity-audit', 'bcba_ai_assistant'];
+                for (const name of protectedNames) {
+                    if (freshResolution.names?.includes(name))
+                        continue;
+                    const content = await getSetting(`skill:${name}`, "");
+                    if (content?.trim()) {
+                        freshSkillBlock += `\n\n[📜 SKILL: ${name}]\n${content.trim()}`;
+                    }
+                }
             }
         }
         catch {
             debugLog(`[session_load_context] Fresh project skill injection failed — continuing without`);
         }
         if (convId) {
-            const { markContextLoaded } = await import("../session/sessionContext.js");
+            const { markContextLoaded, noteDriftSessionStart } = await import("../session/sessionContext.js");
             const { BOUNDARIES_VERSION } = await import("../boundaries/boundaries.js");
             markContextLoaded(convId, project, BOUNDARIES_VERSION);
+            noteDriftSessionStart(convId);
         }
         const { BOUNDARIES_TEXT: BT0, BOUNDARIES_VERSION: BV0 } = await import("../boundaries/boundaries.js");
         const boundariesHeader0 = `# OPERATING BOUNDARIES (v${BV0}) — enforced server-side, shown for transparency\n` +
@@ -907,106 +917,41 @@ export async function sessionLoadContextHandler(args) {
             debugLog(`[session_load_context] Injecting skill for role="${effectiveRole}" (${skillContent.length} chars)`);
         }
     }
-    // ─── Project-Aware Skill Injection ──────────────────────────
-    // 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 sortedSkills = resolved.skills;
-    const userLocalPolicy = resolved.user_local;
-    // F5: surface offline routing to the agent so it knows project/keyword skills may be missing
-    if (resolved.isOffline) {
-        skillBlock += `\n\n[⚠️ OFFLINE ROUTING: synalux.ai unreachable — using stale or fallback routing table. Project-specific and keyword-triggered skills may be missing. Universal protected skills still load.]`;
-    }
-    let synaluxContent = {};
-    if (SYNALUX_CONFIGURED && storage && typeof storage.fetchSkillContent === "function") {
-        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 = 40_000;
-    const skippedSkills = [];
-    for (const entry of sortedSkills) {
-        if (loadedSkills.includes(entry.name))
-            continue;
-        const content = synaluxContent[entry.name] || await getSetting(`skill:${entry.name}`, "");
-        if (!content || !content.trim())
-            continue;
-        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 "${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);
+    // ─── All other skills resolved by portal API ───────────────
+    const { resolveSkills, _setStorage } = await import("./skillRouting.js");
+    _setStorage(async (k, v) => { try {
+        await storage.setSetting?.(k, v);
+    }
+    catch { } }, async (k) => { try {
+        return await getSetting(k, "");
+    }
+    catch {
+        return "";
+    } });
+    const skillResolution = await resolveSkills(project, prompt, effectiveRole);
+    if (skillResolution.skillBlock) {
+        skillBlock += skillResolution.skillBlock;
         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
-    // or explicitly requested). Stored under user_skill: prefix — users can
-    // write here via dashboard; they CANNOT write to the platform skill: keys.
-    if (userLocalPolicy.enabled) {
-        const prefix = userLocalPolicy.key_prefix || "user_skill:";
+        loadedSkills.push(...(skillResolution.names || []));
+    }
+    // Offline fallback: last-good skillBlock was already tried by skillRouting.ts.
+    // If still offline with no skillBlock, load whatever's in local DB as final resort.
+    if (skillResolution.isOffline && !skillResolution.skillBlock) {
         const allSettings = await storage.getAllSettings?.() || {};
         for (const [k, v] of Object.entries(allSettings)) {
-            if (!k.startsWith(prefix) || !v)
-                continue;
-            if (skillBlock.length >= SKILL_BLOCK_CAP)
-                break;
-            const skillName = k.replace(prefix, "");
-            if (loadedSkills.includes(skillName))
-                continue;
-            const trimmed = v.trim();
-            if (skillBlock.length + trimmed.length > SKILL_BLOCK_CAP && loadedSkills.length > 0)
-                continue;
-            skillBlock += `\n\n[📜 USER SKILL: ${skillName}]\n${trimmed}`;
-            loadedSkills.push(skillName);
-            skillLoaded = true;
-            debugLog(`[session_load_context] User-local skill "${skillName}" loaded`);
-        }
-    }
-    // ─── Memory-Based Skill Discovery ──────────────────────────
-    // If recent handoff/ledger mentions a platform skill name, auto-load it.
-    // Only scans platform skill: keys — user_skill: discovery is not automatic.
-    if (formattedContext.length > 0 && skillBlock.length < SKILL_BLOCK_CAP) {
-        const contextText = formattedContext.toLowerCase();
-        const allSkillKeys = await storage.getAllSettings?.() || {};
-        for (const [k, v] of Object.entries(allSkillKeys)) {
             if (!k.startsWith("skill:") || !v)
                 continue;
-            if (skillBlock.length >= SKILL_BLOCK_CAP)
-                break;
-            const skillName = k.replace("skill:", "");
-            if (loadedSkills.includes(skillName))
+            const name = k.replace("skill:", "");
+            if (loadedSkills.includes(name))
                 continue;
-            if (contextText.includes(skillName.replace(/-/g, " ")) || contextText.includes(skillName)) {
-                const trimmed = v.trim();
-                if (skillBlock.length + trimmed.length > SKILL_BLOCK_CAP && loadedSkills.length > 0) {
-                    skippedSkills.push(skillName);
-                    continue;
-                }
-                skillBlock += `\n\n[📜 CONTEXT SKILL: ${skillName}]\n${trimmed}`;
-                loadedSkills.push(skillName);
-                debugLog(`[session_load_context] Context-triggered skill "${skillName}"`);
+            const content = v.trim();
+            if (content && content.trim()) {
+                skillBlock += '\n\n[📜 SKILL: ' + name + ']\n' + content.trim();
+                loadedSkills.push(name);
+                skillLoaded = true;
             }
         }
     }
-    if (skippedSkills.length > 0) {
-        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.
     let greetingBlock = "";
@@ -1114,9 +1059,10 @@ export async function sessionLoadContextHandler(args) {
             responseText += `\n\n[ℹ️ Sections omitted to fit token budget (${maxTokens} tokens): ${droppedSections.join(", ")}. Skills and behavioral rules were preserved.]`;
         }
         if (convId) {
-            const { markContextLoaded } = await import("../session/sessionContext.js");
+            const { markContextLoaded, noteDriftSessionStart } = await import("../session/sessionContext.js");
             const { BOUNDARIES_VERSION } = await import("../boundaries/boundaries.js");
             markContextLoaded(convId, project, BOUNDARIES_VERSION);
+            noteDriftSessionStart(convId);
         }
         const { BOUNDARIES_TEXT, BOUNDARIES_VERSION: BV } = await import("../boundaries/boundaries.js");
         const boundariesHeader = `# OPERATING BOUNDARIES (v${BV}) — enforced server-side, shown for transparency\n` +
@@ -1130,9 +1076,10 @@ export async function sessionLoadContextHandler(args) {
     }
     let responseText = criticalPrefix + lowerPriority + historySection;
     if (convId) {
-        const { markContextLoaded } = await import("../session/sessionContext.js");
+        const { markContextLoaded, noteDriftSessionStart } = await import("../session/sessionContext.js");
         const { BOUNDARIES_VERSION } = await import("../boundaries/boundaries.js");
         markContextLoaded(convId, project, BOUNDARIES_VERSION);
+        noteDriftSessionStart(convId);
     }
     const { BOUNDARIES_TEXT, BOUNDARIES_VERSION: BV2 } = await import("../boundaries/boundaries.js");
     const boundariesHeader2 = `# OPERATING BOUNDARIES (v${BV2}) — enforced server-side, shown for transparency\n` +

package/dist/tools/prismInferHandler.js

@@ -11,7 +11,7 @@
  *   3. Call /api/generate locally — return on success
  *   4. On local fail, if cloud_fallback=true:
  *        - exchange synalux_sk_ → JWT (cached)
- *        - POST synalux portal /api/v1/prism-aac/inference
+ *        - POST synalux portal /api/v1/prism/inference
  *        - portal runs its own cascade (9B/27B/Claude by tier)
  *   5. Return { output, backend, model_picked, ram_free_mb, latency_ms, used_cloud }
  *
@@ -260,7 +260,7 @@ async function callSynaluxInference(prompt, maxTokens, timeoutMs) {
     const jwt = await getSynaluxJwt();
     if (!jwt)
         return { ok: false, reason: "jwt_exchange_failed" };
-    const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism-aac/inference`;
+    const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism/inference`;
     try {
         let res = await fetch(url, {
             method: "POST",

package/dist/tools/sessionMemoryDefinitions.js

@@ -149,6 +149,10 @@ export const SESSION_LOAD_CONTEXT_TOOL = {
                 type: "string",
                 description: "Optional. Session key for this conversation (same id used in session_save_ledger). When provided, marks the session as context-loaded server-side so project-scoped tools can verify working context without relying on hook-based enforcement. Required on non-Claude hosts.",
             },
+            prompt: {
+                type: "string",
+                description: "Optional. User prompt text for keyword-triggered skill loading. When provided, the server matches against prompt_keywords in the routing table and loads additional skills. Fires on every call — enables mid-session re-routing when the user's focus changes.",
+            },
         },
         required: ["project", "toolAction", "toolSummary"],
     },
@@ -584,6 +588,8 @@ export function isSessionLoadContextArgs(args) {
         return false;
     if (a.conversation_id !== undefined && typeof a.conversation_id !== "string")
         return false;
+    if (a.prompt !== undefined && typeof a.prompt !== "string")
+        return false;
     return true;
 }
 // ─── v2.0: Time Travel Tool Definitions ──────────────────────
@@ -1695,6 +1701,11 @@ export const SESSION_DETECT_DRIFT_TOOL = {
     inputSchema: {
         type: "object",
         properties: {
+            conversation_id: {
+                type: "string",
+                description: "Optional. Session key (same id used in session_load_context). " +
+                    "When provided, resets the server-side drift timer for this conversation.",
+            },
             project: {
                 type: "string",
                 description: "Project identifier. Must match the project used in session_save_ledger.",
@@ -1750,6 +1761,8 @@ export function isSessionDetectDriftArgs(args) {
     if (typeof args !== "object" || args === null)
         return false;
     const a = args;
+    if (a.conversation_id !== undefined && typeof a.conversation_id !== "string")
+        return false;
     if (typeof a.project !== "string" || !a.project.trim())
         return false;
     if (typeof a.goal !== "string" || !a.goal.trim())