prism-mcp-server 20.0.1 → 20.0.2

package/README.md

@@ -382,9 +382,9 @@ All on-device models are free to run locally via Ollama on every tier. A subscri
 |---|---|---|---|---|
 | Seats | 1 | 1 | up to 5 | up to 25 |
 | Local model ceiling | up to 4b | up to 9b | up to 27b | up to 27b |
-| Daily cloud inference | -- | 200 | 2,000 | 100,000 |
-| Cloud Coder (Web IDE) | -- | 100/day | 1,000/day | 100,000/day |
-| Cloud search | -- | 50/day | 500/day | 100,000/day |
+| Cloud inference | -- | ✅ | ✅ | ✅ (priority) |
+| Cloud Coder (Web IDE) | -- | ✅ | ✅ | ✅ (priority) |
+| Cloud search | -- | ✅ | ✅ | ✅ |
 | Max output tokens | 512 | 1,024 | 2,048 | 4,096 |
 | Cloud fallback | -- | Claude Opus 4.7 | Claude Opus 4.7 | Priority + Opus 4.7 |
 | Grounding verifier (fact-check AI output) | -- | ✅ | ✅ | ✅ |
@@ -644,11 +644,32 @@ It reads `~/.prism-mcp/data.db` and POSTs entries to the portal. Ledger entries
 
 ## 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.
+**This repository (the Prism MCP client)** is licensed under [Apache-2.0](./LICENSE).
+
+### Free (no account)
+
+| Feature | Details |
+|---------|---------|
+| Local inference | Ollama via `prism_infer`, capped at the 4B model tier |
+| Session memory | Persistent sessions, handoffs, ledger — all local SQLite |
+| Knowledge search | Semantic search across session history |
+| Skills | All skills available locally (run `sync-skills.sh` to populate) |
+| Drift detection | Server-side GATE 5 reminders |
+
+### Paid (Synalux subscription)
+
+Everything in Free, plus:
+
+| Feature | Details |
+|---------|---------|
+| Model ceiling | Up to 27B locally + cloud cascade (9B → 27B → Claude) when local is unavailable |
+| Skill routing | Portal resolves which skills to load based on your project and prompt |
+| Cross-device memory | Supabase cloud sync — sessions survive across machines |
+| Grounding verifier | L3 NLI verification on model outputs |
+| Team features | Multi-agent Hivemind, workspace collaboration |
+
+The paid tier adds **intelligent routing** — the Synalux portal determines which skills are relevant to your current project and prompt, so your agent gets domain expertise (stripe patterns, training protocols, clinical standards) instead of loading everything. Free users with the repo can run `sync-skills.sh` to populate all skills locally; paid routing adds project-aware and prompt-aware selection.
+
 - 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).

package/dist/boundaries/__tests__/boundaries.test.js

@@ -1,11 +1,10 @@
 /**
  * boundaries.ts unit tests
  *
- * Verifies structural invariants of the operating boundaries export:
+ * Verifies structural invariants of the safety declaration:
  * - BOUNDARIES_VERSION is present and non-empty
- * - BOUNDARIES_TEXT covers the five required sections
- * - Safety-critical concepts are mentioned (so a future edit doesn't silently
- *   remove them without also bumping the version and updating tests)
+ * - BOUNDARIES_TEXT covers safety-critical concepts
+ * - Architecture/routing docs moved to server instructions (not per-call)
  */
 import { describe, it, expect } from "vitest";
 import { BOUNDARIES_VERSION, BOUNDARIES_TEXT } from "../../boundaries/boundaries.js";
@@ -16,43 +15,32 @@ describe("BOUNDARIES_VERSION", () => {
     });
 });
 describe("BOUNDARIES_TEXT structure", () => {
-    it("is a non-empty string", () => {
+    it("is a non-empty string under 500 chars (compressed from ~2000)", () => {
         expect(typeof BOUNDARIES_TEXT).toBe("string");
-        expect(BOUNDARIES_TEXT.length).toBeGreaterThan(100);
+        expect(BOUNDARIES_TEXT.length).toBeGreaterThan(50);
+        expect(BOUNDARIES_TEXT.length).toBeLessThan(600);
     });
     it("has no leading or trailing whitespace (trim() was applied)", () => {
         expect(BOUNDARIES_TEXT).toBe(BOUNDARIES_TEXT.trim());
     });
-    it("contains a safety gates section", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/safety gates/i);
-    });
-    it("contains a BCBA clinical standards section", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/bcba/i);
-    });
-    it("contains a correctness gates section", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/correctness gates/i);
-    });
-    it("contains an inference routing section", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/inference routing/i);
+    it("references BCBA reserved categories", () => {
+        expect(BOUNDARIES_TEXT).toMatch(/BCBA reserved/i);
     });
-    it("contains a host note section", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/host note/i);
-    });
-    it("asserts that enforcement is server-side (not instruction-based)", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/server.*enforc|enforc.*server/i);
-    });
-    it("references the fail-closed rule for reserved + no-cloud", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/fail.?closed|refused/i);
+    it("references fail-closed refusal for reserved content", () => {
+        expect(BOUNDARIES_TEXT).toMatch(/refused/i);
     });
     it("states AAC access is never restricted as a consequence", () => {
         expect(BOUNDARIES_TEXT).toMatch(/AAC access is never restricted/i);
     });
-    it("references restraint as a RESERVED category", () => {
+    it("references restraint as reserved", () => {
         expect(BOUNDARIES_TEXT).toMatch(/restraint/i);
-        expect(BOUNDARIES_TEXT).toMatch(/RESERVED/i);
     });
-    it("mentions session_save_ledger and session_save_handoff in correctness section", () => {
-        expect(BOUNDARIES_TEXT).toContain("session_save_ledger");
-        expect(BOUNDARIES_TEXT).toContain("session_save_handoff");
+    it("references crisis/self-harm interception", () => {
+        expect(BOUNDARIES_TEXT).toMatch(/crisis|self-harm/i);
+    });
+    it("does NOT contain architecture/routing docs (those moved to server instructions)", () => {
+        expect(BOUNDARIES_TEXT).not.toContain("session_save_ledger");
+        expect(BOUNDARIES_TEXT).not.toContain("inference routing");
+        expect(BOUNDARIES_TEXT).not.toMatch(/host note/i);
     });
 });

package/dist/boundaries/boundaries.js

@@ -1,48 +1,23 @@
 /**
  * src/boundaries/boundaries.ts
  *
- * Operating boundaries delivered in every session_load_context result.
+ * Safety declaration delivered in every session_load_context result.
+ * Architecture/routing documentation lives in the MCP server description
+ * (loaded once at connection, not per-call).
  *
- * These boundaries are enforced server-side in code (prism_infer safety
- * gates, requireContextLoaded). This text is belt-and-suspenders for a
- * cooperative host — it cannot be removed to bypass enforcement.
+ * The safety gates (Layer 1 classifier, cloud routing, fail-closed refusal)
+ * are enforced in code — this text is defense-in-depth so cooperative hosts
+ * avoid drafting reserved content that would be refused at the gate.
  *
  * Update BOUNDARIES_VERSION any time the text changes so session drift
  * detection can flag stale sessions.
  */
-export const BOUNDARIES_VERSION = "1";
+export const BOUNDARIES_VERSION = "2";
 export const BOUNDARIES_TEXT = `
-## OPERATING BOUNDARIES — server-enforced, shown for transparency
+Safety boundaries are enforced in code — shown so hosts avoid wasted round-trips.
 
-### 1. Safety gates (unconditional — run before and after every model call)
-- Crisis/self-harm inputs are intercepted before reaching any model.
-- BCBA reserved categories (restraint, seclusion, physical management, dosing) route
-  to cloud or refuse; they NEVER generate locally. Fail-closed: if cloud is unavailable
-  and the prompt is reserved, the request is refused — never downgraded to local.
-- Dangerous output (restraint instructions, overdose methods, self-harm guidance)
-  is blocked regardless of which host requested it.
-
-### 2. BCBA clinical standards
-- Apply ABA principles grounded in the current BACB Ethics Code and Task List (5th Ed).
-- Use evidence-based interventions: FCT, DRA, DRO, NCR, antecedent modifications.
-- Least restrictive, dignity-preserving, trauma-informed procedures always.
+- **Crisis/self-harm** inputs are intercepted before reaching any model.
+- **BCBA reserved categories** (restraint, seclusion, physical management, dosing) route to cloud or are refused. They are NEVER generated locally. If cloud is unavailable and the prompt is reserved, the request is refused — never downgraded to local.
+- **Dangerous output** (restraint instructions, overdose methods, self-harm guidance) is blocked regardless of host.
 - AAC access is never restricted as a consequence.
-- Physical management / restraint / seclusion are RESERVED — cloud only, with audit.
-
-### 3. Correctness gates (project-scoped write tools)
-- session_save_ledger and session_save_handoff require a loaded project context
-  (conversation_id that called session_load_context successfully).
-- This prevents a non-Claude host from writing state it hasn't confirmed.
-
-### 4. Inference routing
-- Local inference (Ollama) runs ONLY for OBVIOUS_NOT_RESERVED prompts (Layer 1 verdict).
-- RESERVED / UNCERTAIN / classifier errors escalate to cloud. Never downgrade reserved
-  prompts to local — that is exactly what Layer 1 flagged.
-- Cloud must never be reached directly by a host; all cloud inference routes through
-  the Synalux portal for billing, tier-gating, and HIPAA audit.
-
-### 5. Host note
-These boundaries are enforced by the server. They apply identically whether the host
-is Claude Code, Gemini, an autonomous script, or a cron job. A host that does not read
-this text still cannot bypass the enforcement — it is in code, not instructions.
 `.trim();

package/dist/server.js

@@ -358,7 +358,7 @@ export function createServer() {
         },
         // Supplementary signal — not all clients support this field.
         // Primary mechanism is the dynamic tool description above.
-        instructions: `Prism MCP — The Mind Palace for AI Agents. This server provides persistent session memory, knowledge search, and context management tools. Use session_load_context to recover previous work state, session_save_ledger to log completed work, and session_save_handoff to preserve state for the next session.`,
+        instructions: `Prism MCP — The Mind Palace for AI Agents. This server provides persistent session memory, knowledge search, and context management tools. Use session_load_context to recover previous work state, session_save_ledger to log completed work, and session_save_handoff to preserve state for the next session.\n\nArchitecture: session_save_ledger and session_save_handoff require a loaded project context (conversation_id that called session_load_context). Local inference (prism_infer) routes through Layer 1 classification — RESERVED prompts escalate to cloud or are refused, never served locally. All cloud inference routes through the Synalux portal for billing, tier-gating, and audit.`,
     });
     // ── Handler: Initialize ──
     // NOTE: The SDK's built-in _oninitialize() handles the Initialize request.

package/dist/session/__tests__/sessionContext.test.js

@@ -9,6 +9,7 @@
  * an exported reset function.
  */
 import { describe, it, expect, beforeEach, vi } from "vitest";
+import { BOUNDARIES_VERSION } from "../../boundaries/boundaries.js";
 // Reset module registry before each test so the in-memory Map starts empty.
 let markContextLoaded;
 let requireContextLoaded;
@@ -56,7 +57,7 @@ describe("requireContextLoaded — fail-closed defaults", () => {
 });
 describe("markContextLoaded → requireContextLoaded lifecycle", () => {
     it("returns null (pass) after markContextLoaded is called", () => {
-        markContextLoaded("conv-abc", "project-x", "1");
+        markContextLoaded("conv-abc", "project-x", BOUNDARIES_VERSION);
         expect(requireContextLoaded("conv-abc")).toBeNull();
     });
     it("records project and boundariesVersion on the session", () => {
@@ -68,30 +69,30 @@ describe("markContextLoaded → requireContextLoaded lifecycle", () => {
         expect(state.contextLoaded).toBe(true);
     });
     it("is idempotent — calling twice does not break state", () => {
-        // Use the actual BOUNDARIES_VERSION ("1") so no drift warning fires.
-        markContextLoaded("conv-idem", "proj", "1");
-        markContextLoaded("conv-idem", "proj-updated", "1");
+        // Use the actual BOUNDARIES_VERSION so no drift warning fires.
+        markContextLoaded("conv-idem", "proj", BOUNDARIES_VERSION);
+        markContextLoaded("conv-idem", "proj-updated", BOUNDARIES_VERSION);
         const state = getSessionState("conv-idem");
         expect(state.project).toBe("proj-updated");
-        expect(state.boundariesVersion).toBe("1");
+        expect(state.boundariesVersion).toBe(BOUNDARIES_VERSION);
         expect(requireContextLoaded("conv-idem")).toBeNull();
     });
     it("isolates sessions — loading one does not unblock another", () => {
-        markContextLoaded("conv-A", "proj", "1");
+        markContextLoaded("conv-A", "proj", BOUNDARIES_VERSION);
         expect(requireContextLoaded("conv-A")).toBeNull();
         expect(requireContextLoaded("conv-B")).not.toBeNull();
     });
 });
 describe("noteInferenceForSession", () => {
     it("increments inferenceCalls on every call", () => {
-        markContextLoaded("conv-inf", "proj", "1");
+        markContextLoaded("conv-inf", "proj", BOUNDARIES_VERSION);
         noteInferenceForSession("conv-inf", { backend: "local", usedCloud: false });
         noteInferenceForSession("conv-inf", { backend: "local", usedCloud: false });
         const state = getSessionState("conv-inf");
         expect(state.inferenceCalls).toBe(2);
     });
     it("increments usedCloudCalls only for cloud calls", () => {
-        markContextLoaded("conv-cloud", "proj", "1");
+        markContextLoaded("conv-cloud", "proj", BOUNDARIES_VERSION);
         noteInferenceForSession("conv-cloud", { backend: "cloud", usedCloud: true });
         noteInferenceForSession("conv-cloud", { backend: "local", usedCloud: false });
         const state = getSessionState("conv-cloud");
@@ -112,7 +113,7 @@ describe("getSessionState", () => {
         expect(getSessionState("does-not-exist")).toBeNull();
     });
     it("returns the current state object for a known session", () => {
-        markContextLoaded("conv-get", "proj", "1");
+        markContextLoaded("conv-get", "proj", BOUNDARIES_VERSION);
         const state = getSessionState("conv-get");
         expect(state).not.toBeNull();
         expect(state.contextLoaded).toBe(true);
@@ -120,7 +121,7 @@ describe("getSessionState", () => {
 });
 describe("lastSeen update", () => {
     it("updates lastSeen on every requireContextLoaded call", async () => {
-        markContextLoaded("conv-ts", "proj", "1");
+        markContextLoaded("conv-ts", "proj", BOUNDARIES_VERSION);
         const before = getSessionState("conv-ts").lastSeen;
         // Advance time by mocking Date.now via vi.useFakeTimers
         vi.useFakeTimers();

package/dist/storage/sqlite.js

@@ -909,6 +909,19 @@ export class SqliteStorage {
     async saveLedger(entry) {
         const id = entry.id || randomUUID();
         const now = new Date().toISOString();
+        // Dedup: skip if an identical (project, conversation_id, summary) exists within 5 minutes
+        if (entry.project && entry.conversation_id && entry.summary) {
+            const dup = await this.db.execute({
+                sql: `SELECT id FROM session_ledger
+          WHERE project = ? AND conversation_id = ? AND summary = ?
+          AND created_at > datetime('now', '-5 minutes')
+          LIMIT 1`,
+                args: [entry.project, entry.conversation_id, entry.summary],
+            });
+            if (dup.rows.length > 0) {
+                return { id: dup.rows[0].id, deduplicated: true };
+            }
+        }
         await this.db.execute({
             sql: `INSERT INTO session_ledger
         (id, project, conversation_id, user_id, role, summary, todos, files_changed,

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

@@ -75,6 +75,7 @@ function makeBaseDeps(overrides = {}) {
         listLoaded: async () => new Set(),
         callLocal: async () => ({ ok: true, text: "local response", doneReason: "stop" }),
         callCloud: async () => ({ ok: true, output: "cloud response", backend: "synalux" }),
+        callLayer1: async () => "OBVIOUS_NOT_RESERVED",
         ollamaUrl: "http://localhost:11434",
         entitlements: {
             plan: "pro",
@@ -138,11 +139,18 @@ describe("Layer 1 handler integration", () => {
         expect(callLocal).toHaveBeenCalled();
         expect(result.used_cloud).toBe(false);
     });
-    it("cloud_fallback=false → Layer 1 skipped entirely", async () => {
+    it("cloud_fallback=false + RESERVED → refuses (fail-closed, no local fallback)", async () => {
         const callLayer1Mock = vi.fn().mockResolvedValue("OBVIOUS_RESERVED");
         const callLocal = vi.fn().mockResolvedValue({ ok: true, text: "local response", doneReason: "stop" });
-        const result = await runInfer({ prompt: "write something", mode: "code", cloud_fallback: false, max_tokens: 512 }, makeBaseDeps({ callLayer1: callLayer1Mock, callLocal }));
-        expect(callLayer1Mock).not.toHaveBeenCalled();
+        await expect(runInfer({ prompt: "write something", mode: "code", cloud_fallback: false, max_tokens: 512 }, makeBaseDeps({ callLayer1: callLayer1Mock, callLocal }))).rejects.toThrow(/reserved content refused/i);
+        expect(callLayer1Mock).toHaveBeenCalled();
+        expect(callLocal).not.toHaveBeenCalled();
+    });
+    it("cloud_fallback=false + NOT_RESERVED → proceeds to local", async () => {
+        const callLayer1Mock = vi.fn().mockResolvedValue("OBVIOUS_NOT_RESERVED");
+        const callLocal = vi.fn().mockResolvedValue({ ok: true, text: "local response", doneReason: "stop" });
+        const result = await runInfer({ prompt: "what is 2+2?", mode: "code", cloud_fallback: false, max_tokens: 512 }, makeBaseDeps({ callLayer1: callLayer1Mock, callLocal }));
+        expect(callLayer1Mock).toHaveBeenCalled();
         expect(result.used_cloud).toBe(false);
     });
     it("recursion guard: mode=route + max_tokens<=16 skips Layer 1", async () => {

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

@@ -531,11 +531,33 @@ describe("ledgerHandlers", () => {
             await sessionLoadContextHandler({ project: "test-project" });
             expect(vi.mocked(markContextLoaded)).not.toHaveBeenCalled();
         });
-        it("prepends BOUNDARIES header to every response", async () => {
+        it("prepends safety header on no-history path", async () => {
             storage.loadContext.mockResolvedValue(null);
             const result = await sessionLoadContextHandler(validArgs);
             const text = result.content[0].text;
-            expect(text).toContain("OPERATING BOUNDARIES");
+            expect(text).toContain("Safety Boundaries");
+            expect(text).toContain("BOUNDARIES STUB");
+            expect(text).toContain("no previous session history");
+        });
+        it("prepends safety header on history-found path (standard/deep)", async () => {
+            storage.loadContext.mockResolvedValue({
+                last_summary: "Did some work",
+                version: 1,
+            });
+            const result = await sessionLoadContextHandler({ ...validArgs, level: "standard" });
+            const text = result.content[0].text;
+            expect(text).toContain("Safety Boundaries");
+            expect(text).toContain("BOUNDARIES STUB");
+            expect(text).toContain("Did some work");
+        });
+        it("prepends safety header on quick path", async () => {
+            storage.loadContext.mockResolvedValue({
+                last_summary: "Quick summary",
+                version: 2,
+            });
+            const result = await sessionLoadContextHandler({ ...validArgs, level: "quick" });
+            const text = result.content[0].text;
+            expect(text).toContain("Safety Boundaries");
             expect(text).toContain("BOUNDARIES STUB");
         });
     });

package/dist/tools/ledgerHandlers.js

@@ -670,10 +670,7 @@ export async function sessionLoadContextHandler(args) {
             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` +
-            BT0 + "\n\n" +
-            `# NOTE FOR NON-CLAUDE HOSTS: these boundaries run in code on every prism_infer call.\n` +
-            `# Reserved-category requests are routed to cloud or refused — not by instruction.\n\n---\n\n`;
+        const boundariesHeader0 = `# Safety Boundaries (v${BV0})\n${BT0}\n\n---\n\n`;
         return {
             content: [{
                     type: "text",
@@ -944,7 +941,10 @@ export async function sessionLoadContextHandler(args) {
             skillLoaded = true;
         }
     }
-    // Offline fallback: load whatever's in local DB
+    // Offline fallback: load ALL local skill: content (no tier gating).
+    // Deliberate: offline = degraded = best-effort. A repo-holder with
+    // sync-skills.sh has the full library locally regardless of tier.
+    // Tier gating is portal-side (name resolution); offline bypasses it.
     if (skillResolution.isOffline) {
         const allSettings = await storage.getAllSettings?.() || {};
         for (const [k, v] of Object.entries(allSettings)) {
@@ -1074,10 +1074,7 @@ export async function sessionLoadContextHandler(args) {
             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` +
-            BOUNDARIES_TEXT + "\n\n" +
-            `# NOTE FOR NON-CLAUDE HOSTS: these boundaries run in code on every prism_infer call.\n` +
-            `# Reserved-category requests are routed to cloud or refused — not by instruction.\n\n---\n\n`;
+        const boundariesHeader = `# Safety Boundaries (v${BV})\n${BOUNDARIES_TEXT}\n\n---\n\n`;
         return {
             content: [{ type: "text", text: boundariesHeader + responseText + MEMORY_BOUNDARY_SUFFIX }],
             isError: false,
@@ -1091,10 +1088,7 @@ export async function sessionLoadContextHandler(args) {
         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` +
-        BOUNDARIES_TEXT + "\n\n" +
-        `# NOTE FOR NON-CLAUDE HOSTS: these boundaries run in code on every prism_infer call.\n` +
-        `# Reserved-category requests are routed to cloud or refused — not by instruction.\n\n---\n\n`;
+    const boundariesHeader2 = `# Safety Boundaries (v${BV2})\n${BOUNDARIES_TEXT}\n\n---\n\n`;
     return {
         content: [{ type: "text", text: boundariesHeader2 + responseText + MEMORY_BOUNDARY_SUFFIX }],
         isError: false,

package/dist/tools/prismInferHandler.js

@@ -412,36 +412,38 @@ export async function runInfer(args, deps) {
         attempts.push({ tier: "ollama_probe", reason: "unreachable" });
     }
     // ── §E Layer 1 semantic pre-classifier ──────────────────────────────────
-    // Catches adversarial paraphrases the keyword stub misses.
-    // Runs only when cloud escalation is possible — without cloud, there is
-    // nowhere to route a RESERVED verdict.
+    // Runs for ALL tiers when Ollama is reachable. RESERVED prompts escalate
+    // to cloud if available; otherwise refuse (fail-closed). Free-tier users
+    // without cloud still get classified — a RESERVED verdict refuses the
+    // request rather than silently routing to local.
     // Recursion guard: skip when this call IS the Layer 1 classification
     // (mode="route" + max_tokens<=16 is the Layer 1 call signature).
     const layer1RecursionGuard = mode === "route" && maxTokens <= 16;
-    if (allowCloud && !layer1RecursionGuard) {
+    if (installed && !layer1RecursionGuard) {
         const l1fn = deps.callLayer1 ?? defaultCallLayer1;
-        const l1Model = resolveOllamaName("prism-coder:4b", installed ?? new Set());
+        const l1Model = resolveOllamaName("prism-coder:4b", installed);
         const l1 = await l1fn(args.prompt, deps.ollamaUrl, l1Model);
         if (l1 !== "OBVIOUS_NOT_RESERVED") {
-            debugLog(`[prism_infer] Layer 1 verdict=${l1} — escalating to cloud`);
+            debugLog(`[prism_infer] Layer 1 verdict=${l1} — reserved content detected`);
             attempts.push({ tier: "layer1", reason: `layer1_${l1.toLowerCase()}` });
-            const cloudTimeout = args.timeout_ms ?? 90_000;
-            const cloud = await deps.callCloud(args.prompt, maxTokens, cloudTimeout);
-            if (cloud.ok && cloud.output) {
-                return await applyVerification(cloud.output, gatedArgs, deps, {
-                    backend: cloud.backend ?? "synalux",
-                    model_picked: null,
-                    ram_free_mb: ramFreeMb,
-                    latency_ms: Date.now() - t0,
-                    used_cloud: true,
-                    attempts,
-                    plan: ent.plan,
-                    completion_tokens: Math.ceil(cloud.output.length / 4),
-                });
+            if (allowCloud) {
+                const cloudTimeout = args.timeout_ms ?? 90_000;
+                const cloud = await deps.callCloud(args.prompt, maxTokens, cloudTimeout);
+                if (cloud.ok && cloud.output) {
+                    return await applyVerification(cloud.output, gatedArgs, deps, {
+                        backend: cloud.backend ?? "synalux",
+                        model_picked: null,
+                        ram_free_mb: ramFreeMb,
+                        latency_ms: Date.now() - t0,
+                        used_cloud: true,
+                        attempts,
+                        plan: ent.plan,
+                        completion_tokens: Math.ceil(cloud.output.length / 4),
+                    });
+                }
+                attempts.push({ tier: "synalux", reason: cloud.reason ?? "unknown" });
             }
-            attempts.push({ tier: "synalux", reason: cloud.reason ?? "unknown" });
-            // Layer 1 flagged RESERVED but cloud unavailable — fail closed, never fall through to local.
-            throw new Error(`prism_infer: Layer 1 verdict=${l1} but cloud unavailable. attempts=${JSON.stringify(attempts)}`);
+            throw new Error(`prism_infer: Layer 1 verdict=${l1}, reserved content refused. attempts=${JSON.stringify(attempts)}`);
         }
         debugLog(`[prism_infer] Layer 1 verdict=OBVIOUS_NOT_RESERVED — proceeding local`);
     }

package/dist/utils/entitlements.js

@@ -15,7 +15,7 @@ import { debugLog } from "./logger.js";
 export const FREE_ENTITLEMENTS = {
     plan: "free",
     model_ceiling: "4b",
-    daily_infer_limit: 50,
+    daily_infer_limit: 50, // reserved, not enforced; cloud limits are portal-side
     max_tokens: 512,
     max_seats: 1,
     features: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.0.1",
+  "version": "20.0.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.",
   "module": "index.ts",