prism-mcp-server 19.2.8 → 19.2.9

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

@@ -54,6 +54,7 @@ vi.mock("../../../src/config.js", () => ({
     PRISM_GRAPH_PRUNE_MAX_PROJECTS_PER_SWEEP: 25,
     PRISM_ACTR_ENABLED: false,
     PRISM_ACTR_ACCESS_LOG_RETENTION_DAYS: 90,
+    SYNALUX_CONFIGURED: false,
 }));
 vi.mock("../../../src/utils/logger.js", () => ({
     debugLog: vi.fn(),
@@ -427,7 +428,7 @@ describe("ledgerHandlers", () => {
             });
             const text = result.content[0].text;
             // With 100 tokens * 4 chars = 400 char budget, the 5000-char summary gets truncated
-            expect(text).toContain("truncated to fit token budget");
+            expect(text).toContain("Sections omitted to fit token budget");
         });
         it("includes recent sessions in formatted output", async () => {
             storage.loadContext.mockResolvedValue({
@@ -677,36 +678,36 @@ describe("ledgerHandlers", () => {
     describe("sessionForgetMemoryHandler", () => {
         it("soft-deletes a memory entry by default", async () => {
             const result = await sessionForgetMemoryHandler({
-                memory_id: "uuid-123",
+                memory_id: "550e8400-e29b-41d4-a716-446655440123",
             });
             expect(result.isError).toBe(false);
             expect(result.content[0].text).toContain("Soft Deleted");
-            expect(result.content[0].text).toContain("uuid-123");
-            expect(storage.softDeleteLedger).toHaveBeenCalledWith("uuid-123", "test-user-id", undefined);
+            expect(result.content[0].text).toContain("550e8400-e29b-41d4-a716-446655440123");
+            expect(storage.softDeleteLedger).toHaveBeenCalledWith("550e8400-e29b-41d4-a716-446655440123", "test-user-id", undefined);
         });
         it("soft-deletes with reason for audit trail", async () => {
             const result = await sessionForgetMemoryHandler({
-                memory_id: "uuid-456",
+                memory_id: "550e8400-e29b-41d4-a716-446655440456",
                 reason: "GDPR Article 17 request",
             });
             expect(result.isError).toBe(false);
             expect(result.content[0].text).toContain("Reason");
             expect(result.content[0].text).toContain("GDPR Article 17 request");
-            expect(storage.softDeleteLedger).toHaveBeenCalledWith("uuid-456", "test-user-id", "GDPR Article 17 request");
+            expect(storage.softDeleteLedger).toHaveBeenCalledWith("550e8400-e29b-41d4-a716-446655440456", "test-user-id", "GDPR Article 17 request");
         });
         it("hard-deletes when hard_delete is true", async () => {
             const result = await sessionForgetMemoryHandler({
-                memory_id: "uuid-789",
+                memory_id: "550e8400-e29b-41d4-a716-446655440789",
                 hard_delete: true,
             });
             expect(result.isError).toBe(false);
             expect(result.content[0].text).toContain("Hard Deleted");
             expect(result.content[0].text).toContain("permanently removed");
-            expect(storage.hardDeleteLedger).toHaveBeenCalledWith("uuid-789", "test-user-id");
+            expect(storage.hardDeleteLedger).toHaveBeenCalledWith("550e8400-e29b-41d4-a716-446655440789", "test-user-id");
         });
         it("does not call hardDeleteLedger when hard_delete is false", async () => {
             await sessionForgetMemoryHandler({
-                memory_id: "uuid-aaa",
+                memory_id: "550e8400-e29b-41d4-a716-446655440aaa",
                 hard_delete: false,
             });
             expect(storage.hardDeleteLedger).not.toHaveBeenCalled();
@@ -731,7 +732,7 @@ describe("ledgerHandlers", () => {
         it("catches storage errors and returns isError (never throws)", async () => {
             storage.softDeleteLedger.mockRejectedValue(new Error("Entry not found"));
             const result = await sessionForgetMemoryHandler({
-                memory_id: "nonexistent-uuid",
+                memory_id: "550e8400-e29b-41d4-a716-446655440f99",
             });
             expect(result.isError).toBe(true);
             expect(result.content[0].text).toContain("Entry not found");
@@ -739,7 +740,7 @@ describe("ledgerHandlers", () => {
         it("catches hard_delete storage errors gracefully", async () => {
             storage.hardDeleteLedger.mockRejectedValue(new Error("FK constraint"));
             const result = await sessionForgetMemoryHandler({
-                memory_id: "uuid-fail",
+                memory_id: "550e8400-e29b-41d4-a716-446655440f11",
                 hard_delete: true,
             });
             expect(result.isError).toBe(true);
@@ -753,6 +754,7 @@ describe("ledgerHandlers", () => {
         let tempDir;
         beforeEach(async () => {
             tempDir = await mkdtemp(join(tmpdir(), "prism-handler-export-"));
+            process.env.PRISM_EXPORT_ROOT = tempDir;
             storage.listProjects.mockResolvedValue(["test-project"]);
             storage.getLedgerEntries.mockResolvedValue([
                 { id: "entry-1", summary: "Session 1", importance: 3 },
@@ -763,6 +765,7 @@ describe("ledgerHandlers", () => {
             });
         });
         afterEach(async () => {
+            delete process.env.PRISM_EXPORT_ROOT;
             await rm(tempDir, { recursive: true, force: true });
         });
         it("exports JSON file for a single project", async () => {
@@ -832,7 +835,7 @@ describe("ledgerHandlers", () => {
         });
         afterEach(async () => {
             // Clean up vault directory if created
-            const vaultDir = join(os.homedir(), ".prism-mcp", "media", "test-project");
+            const vaultDir = join(os.homedir(), ".prism-mcp", "media", "__test-img__");
             if (fs.existsSync(vaultDir)) {
                 await rm(vaultDir, { recursive: true, force: true });
             }
@@ -840,7 +843,7 @@ describe("ledgerHandlers", () => {
         });
         it("saves an image and returns success with image ID", async () => {
             const result = await sessionSaveImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 file_path: testImagePath,
                 description: "Dashboard screenshot",
             });
@@ -851,7 +854,7 @@ describe("ledgerHandlers", () => {
         });
         it("updates handoff metadata with visual memory entry", async () => {
             await sessionSaveImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 file_path: testImagePath,
                 description: "UI mockup",
             });
@@ -862,8 +865,8 @@ describe("ledgerHandlers", () => {
         });
         it("returns error for non-existent file", async () => {
             const result = await sessionSaveImageHandler({
-                project: "test-project",
-                file_path: "/nonexistent/path/image.png",
+                project: "__test-img__",
+                file_path: join(tempDir, "does-not-exist.png"),
                 description: "Missing image",
             });
             expect(result.isError).toBe(true);
@@ -873,7 +876,7 @@ describe("ledgerHandlers", () => {
             const bmpPath = join(tempDir, "test.bmp");
             fs.writeFileSync(bmpPath, Buffer.from([0x42, 0x4d]));
             const result = await sessionSaveImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 file_path: bmpPath,
                 description: "BMP image",
             });
@@ -883,7 +886,7 @@ describe("ledgerHandlers", () => {
         it("returns error when no active context exists", async () => {
             storage.loadContext.mockResolvedValue(null);
             const result = await sessionSaveImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 file_path: testImagePath,
                 description: "No context image",
             });
@@ -893,7 +896,7 @@ describe("ledgerHandlers", () => {
         // --- Input Validation ---
         it("returns error for invalid args (missing required fields)", async () => {
             const result = await sessionSaveImageHandler({
-                project: "test-project",
+                project: "__test-img__",
             });
             expect(result.isError).toBe(true);
             expect(result.content[0].text).toContain("Invalid arguments");
@@ -912,7 +915,7 @@ describe("ledgerHandlers", () => {
         let vaultImagePath;
         beforeEach(async () => {
             tempDir = await mkdtemp(join(tmpdir(), "prism-view-image-test-"));
-            vaultDir = join(os.homedir(), ".prism-mcp", "media", "test-project");
+            vaultDir = join(os.homedir(), ".prism-mcp", "media", "__test-img__");
             fs.mkdirSync(vaultDir, { recursive: true });
             // Create a test image in the vault
             vaultImagePath = join(vaultDir, "abc12345.png");
@@ -941,7 +944,7 @@ describe("ledgerHandlers", () => {
                 },
             });
             const result = await sessionViewImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 image_id: "abc12345",
             });
             expect(result.isError).toBe(false);
@@ -964,7 +967,7 @@ describe("ledgerHandlers", () => {
                 },
             });
             const result = await sessionViewImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 image_id: "nonexistent",
             });
             expect(result.isError).toBe(true);
@@ -976,7 +979,7 @@ describe("ledgerHandlers", () => {
                 metadata: {},
             });
             const result = await sessionViewImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 image_id: "any-id",
             });
             expect(result.isError).toBe(true);
@@ -997,7 +1000,7 @@ describe("ledgerHandlers", () => {
                 },
             });
             const result = await sessionViewImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 image_id: "abc12345",
             });
             expect(result.isError).toBe(true);
@@ -1018,7 +1021,7 @@ describe("ledgerHandlers", () => {
                 },
             });
             const result = await sessionViewImageHandler({
-                project: "test-project",
+                project: "__test-img__",
                 image_id: "abc12345",
             });
             expect(result.isError).toBe(false);
@@ -1028,7 +1031,7 @@ describe("ledgerHandlers", () => {
         // --- Input Validation ---
         it("returns error for invalid args (missing image_id)", async () => {
             const result = await sessionViewImageHandler({
-                project: "test-project",
+                project: "__test-img__",
             });
             expect(result.isError).toBe(true);
         });
@@ -1154,13 +1157,13 @@ describe("ledgerHandlers", () => {
         });
         it("sessionForgetMemoryHandler includes 'tombstoned' in soft-delete response", async () => {
             const result = await sessionForgetMemoryHandler({
-                memory_id: "uuid-test",
+                memory_id: "550e8400-e29b-41d4-a716-446655440001",
             });
             expect(result.content[0].text).toContain("tombstoned");
         });
         it("sessionForgetMemoryHandler mentions hard_delete option in soft-delete response", async () => {
             const result = await sessionForgetMemoryHandler({
-                memory_id: "uuid-test",
+                memory_id: "550e8400-e29b-41d4-a716-446655440001",
             });
             expect(result.content[0].text).toContain("hard_delete: true");
         });

package/dist/tools/ledgerHandlers.js

@@ -89,7 +89,7 @@ const MEMORY_BOUNDARY_SUFFIX = '\n</prism_memory>';
  * After saving, generates an embedding vector for the entry via fire-and-forget.
  */
 import { computeEffectiveImportance, recordMemoryAccess } from "../utils/cognitiveMemory.js";
-import { formatInferenceMetrics, resetInferenceMetrics } from "../utils/inferenceMetrics.js";
+import { formatInferenceMetrics, resetInferenceMetrics, getInferenceSnapshot } from "../utils/inferenceMetrics.js";
 export async function sessionSaveLedgerHandler(args) {
     if (!isSessionSaveLedgerArgs(args)) {
         throw new Error("Invalid arguments for session_save_ledger");
@@ -581,10 +581,17 @@ export async function sessionLoadContextHandler(args) {
     if (!isSessionLoadContextArgs(args)) {
         throw new Error("Invalid arguments for session_load_context");
     }
-    resetInferenceMetrics();
+    // T3 fix: only reset metrics at true session start (totalCalls==0), not on GATE 5 mid-session
+    // reloads. Resetting on every call wipes accumulated delegation metrics right before
+    // session_save_ledger renders them, making the 📊 block show near-zero after any reload.
+    if (getInferenceSnapshot().totalCalls === 0) {
+        resetInferenceMetrics();
+    }
     const { project, level = "standard", role } = args;
-    const maxTokens = args.max_tokens
-        || parseInt(await getSetting("max_tokens", "0"), 10) || undefined; // v4.0: arg > dashboard setting > none
+    // 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);
+    const maxTokens = (_maxTokensArg > 0 ? _maxTokensArg : undefined) ?? (_maxTokensSetting > 0 ? _maxTokensSetting : undefined);
     const agentName = await getSetting("agent_name", "");
     const validLevels = ["quick", "standard", "deep"];
     if (!validLevels.includes(level)) {
@@ -600,12 +607,30 @@ export async function sessionLoadContextHandler(args) {
     const storage = await getStorage();
     const effectiveRole = role || await getSetting("default_role", "") || undefined;
     const data = await storage.loadContext(project, level, PRISM_USER_ID, effectiveRole); // v3.0: role with dashboard fallback
+    // F4 fix: inject protected skills even for fresh projects.
+    // Previously this returned before skill injection, leaving new projects with zero
+    // behavioral guardrails for the entire session. Now protected skills always load.
     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()}`;
+            }
+        }
+        catch {
+            debugLog(`[session_load_context] Fresh project skill injection failed — continuing without`);
+        }
         return {
             content: [{
                     type: "text",
                     text: `No session context found for project "${project}" at level ${level}.\n` +
-                        `This project has no previous session history. Starting fresh.`,
+                        `This project has no previous session history. Starting fresh.` +
+                        freshSkillBlock,
                 }],
             isError: false,
         };
@@ -855,6 +880,10 @@ export async function sessionLoadContextHandler(args) {
     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));
@@ -994,12 +1023,8 @@ export async function sessionLoadContextHandler(args) {
             behavWarnings.map(w => `- ${w.summary} (importance: ${w.importance})`).join("\n");
         behavBlock = [...rawBlock].slice(0, 2000).join('');
     }
-    let responseText = `${MEMORY_BOUNDARY_PREFIX}📋 Session context for "${project}" (${level}):\n\n${formattedContext.trim()}${splitBrainWarning}${driftReport}${briefingBlock}${sdmRecallBlock}${greetingBlock}${visualMemoryBlock}${behavBlock}${skillBlock}${versionNote}`;
     // ─── v9.4.7: ABA Precision Protocol (foundational) ────────
-    // Injected into EVERY session load so the agent always operates
-    // under these behavioral rules. Never truncated (placed before
-    // token budget check).
-    responseText += `\n\n[🧠 ABA PRECISION PROTOCOL]\n` +
+    const abaProtocol = `\n\n[🧠 ABA PRECISION PROTOCOL]\n` +
         `Rule 1 — Observable Goals: Every task must have a measurable, verifiable outcome. State the specific result.\n` +
         `Rule 2 — Precise Execution: One step at a time. Verify each step. If it fails → STOP → fix → verify → then continue.\n` +
         `Rule 3 — No Reinforcement of Errors: Never repeat the same mistake twice. When the user says something is wrong, read the actual code/data FIRST before forming an opinion.\n` +
@@ -1007,15 +1032,57 @@ export async function sessionLoadContextHandler(args) {
         `Rule 5 — Fix Without Asking: When you see a bug, fix it immediately. Do NOT ask "would you like me to fix that?" — just fix it.\n` +
         `Rule 6 — Action Intent: When user says "fix/run/open/deploy", they want ACTION not a tutorial. Ask for specific info needed in 1-2 sentences, or act directly.\n` +
         `Rule 7 — Tool Redirect: When user asks to "open browser"/"run terminal"/"git push" — output ONLY the URL or command. No follow-up. No explanations. Example: "open browser" → "https://synalux.ai/dashboard"`;
-    // ─── v4.0: Token Budget Truncation ─────────────────────────
-    // 1 token ≈ 4 chars heuristic. Truncate if response exceeds budget.
+    // T5 structural truncation: assemble sections in priority order so budget truncation
+    // drops the LEAST critical sections first (session history), never skills.
+    // Priority high→low: ABA | skills | behavioral warnings | version | drift | briefing | SDM | history
+    // The header + critical rules are always at the top; history is appended last.
+    const criticalPrefix = `${MEMORY_BOUNDARY_PREFIX}📋 Session context for "${project}" (${level}):\n\n` +
+        abaProtocol +
+        behavBlock +
+        skillBlock +
+        versionNote +
+        greetingBlock +
+        splitBrainWarning;
+    const lowerPriority = driftReport +
+        briefingBlock +
+        sdmRecallBlock +
+        visualMemoryBlock;
+    const historySection = formattedContext.trim()
+        ? `\n\n---\n\n📋 Historical Context:\n${formattedContext.trim()}`
+        : "";
+    // ─── v4.0: Token Budget Truncation (T5 structural version) ──
+    // Drops low-priority sections whole (no mid-slice) before falling back
+    // to trimming the history block. Protected sections (skills, ABA) always survive.
+    // T1: use ~3.5 chars/token (better for emoji+code payload) instead of flat 4.
     if (maxTokens && maxTokens > 0) {
-        const maxChars = maxTokens * 4;
+        const maxChars = Math.floor(maxTokens * 3.5);
+        const droppedSections = [];
+        let responseText = criticalPrefix + lowerPriority + historySection;
         if (responseText.length > maxChars) {
-            responseText = responseText.slice(0, maxChars) + "\n\n[… truncated to fit token budget]";
-            debugLog(`[session_load_context] Truncated response to ${maxTokens} tokens (${maxChars} chars)`);
+            // Drop low-priority sections first (SDM recall, briefing, drift)
+            responseText = criticalPrefix + historySection;
+            droppedSections.push("briefing", "drift-report", "sdm-recall");
+            debugLog(`[session_load_context] T5: dropped low-priority sections (${droppedSections.join(", ")})`);
+            if (responseText.length > maxChars) {
+                // History too long — trim it, preserving all critical sections
+                const histAllowed = Math.max(0, maxChars - criticalPrefix.length - 200);
+                const trimmedHistory = histAllowed > 0
+                    ? `\n\n---\n\n📋 Historical Context (trimmed):\n${formattedContext.trim().slice(0, histAllowed)}…`
+                    : "";
+                droppedSections.push("partial-history");
+                responseText = criticalPrefix + trimmedHistory;
+                debugLog(`[session_load_context] T5: trimmed history to ${histAllowed} chars`);
+            }
+        }
+        if (droppedSections.length > 0) {
+            responseText += `\n\n[ℹ️ Sections omitted to fit token budget (${maxTokens} tokens): ${droppedSections.join(", ")}. Skills and behavioral rules were preserved.]`;
         }
+        return {
+            content: [{ type: "text", text: responseText + MEMORY_BOUNDARY_SUFFIX }],
+            isError: false,
+        };
     }
+    let responseText = criticalPrefix + lowerPriority + historySection;
     return {
         content: [{ type: "text", text: responseText + MEMORY_BOUNDARY_SUFFIX }],
         isError: false,

package/dist/tools/prismInferHandler.js

@@ -22,14 +22,15 @@
 import { pickLocalModel, fmtGb, MODEL_TIERS, resolveOllamaName } from "../utils/modelPicker.js";
 import { getSynaluxJwt, invalidateSynaluxJwt } from "../utils/synaluxJwt.js";
 import { getAvailableMemoryBytes } from "../utils/availableMemory.js";
-import { PRISM_SYNALUX_BASE_URL, PRISM_LOCAL_LLM_URL, } from "../config.js";
+import { PRISM_SYNALUX_BASE_URL, PRISM_LOCAL_LLM_URL, SYNALUX_CONFIGURED, } from "../config.js";
 import { debugLog } from "../utils/logger.js";
 import { getEntitlements, clampCeiling } from "../utils/entitlements.js";
 import { ddLog } from "../utils/ddLogger.js";
 import { stripThink } from "../utils/thinkStrip.js";
 import { passesQualityGate } from "../utils/qualityGate.js";
 import { checkInputSafety, checkOutputSafety } from "../utils/safetyGate.js";
-import { recordInference } from "../utils/inferenceMetrics.js";
+import { callLayer1 as defaultCallLayer1 } from "../utils/layer1.js";
+import { recordInference, formatInferenceMetrics } from "../utils/inferenceMetrics.js";
 // ─── Tool Definition ────────────────────────────────────────────
 export const PRISM_INFER_TOOL = {
     name: "prism_infer",
@@ -299,6 +300,48 @@ async function callSynaluxInference(prompt, maxTokens, timeoutMs) {
         return { ok: false, reason: name === "TimeoutError" || name === "AbortError" ? "synalux_timeout" : "synalux_network" };
     }
 }
+// ─── Portal verifier (thin-client HTTP call) ──────────────────
+async function callSynaluxVerifier(opts) {
+    if (!PRISM_SYNALUX_BASE_URL)
+        throw new Error("no_synalux_base_url");
+    const jwt = await getSynaluxJwt();
+    if (!jwt)
+        throw new Error("jwt_exchange_failed");
+    const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism/verify-grounding`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${jwt}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            draft: opts.draft,
+            evidence: opts.evidence,
+            verifierModel: opts.verifierModel,
+            // Give portal 500ms headroom before our own AbortSignal fires.
+            timeoutMs: Math.max(500, (opts.timeoutMs ?? 5_000) - 500),
+        }),
+        signal: AbortSignal.timeout(opts.timeoutMs ?? 5_000),
+        redirect: "error",
+    });
+    if (!res.ok)
+        throw new Error(`synalux_verifier_http_${res.status}`);
+    return res.json();
+}
+// In-process mutex that serialises eviction so concurrent requests don't evict
+// a model that another in-flight inference is actively using (F3 fix).
+const _evictionMutex = (() => {
+    let _lock = Promise.resolve();
+    return {
+        acquire() {
+            let release;
+            const next = new Promise(resolve => { release = resolve; });
+            const chain = _lock.then(() => release);
+            _lock = _lock.then(() => next);
+            return chain;
+        },
+    };
+})();
 export async function runInfer(args, deps) {
     const t0 = Date.now();
     const temperature = args.temperature ?? 0;
@@ -366,14 +409,105 @@ export async function runInfer(args, deps) {
     if (installed === null) {
         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.
+    // 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) {
+        const l1fn = deps.callLayer1 ?? defaultCallLayer1;
+        const l1Model = resolveOllamaName("prism-coder:4b", installed ?? new Set());
+        const l1 = await l1fn(args.prompt, deps.ollamaUrl, l1Model);
+        if (l1 !== "OBVIOUS_NOT_RESERVED") {
+            debugLog(`[prism_infer] Layer 1 verdict=${l1} — escalating to cloud`);
+            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),
+                });
+            }
+            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)}`);
+        }
+        debugLog(`[prism_infer] Layer 1 verdict=OBVIOUS_NOT_RESERVED — proceeding local`);
+    }
+    // ── end Layer 1 ─────────────────────────────────────────────────────────
     // Walk the tier table top → bottom, capped by model_ceiling. Each tier
     // logs its skip reason ("not_pulled" / "ram_insufficient" / fail reason)
     // so the caller can see exactly why each tier was bypassed.
     let localDraft = null;
     if (installed) {
-        const ceilStart = effectiveCeiling
-            ? Math.max(0, MODEL_TIERS.findIndex(t => t.tag.endsWith(`:${effectiveCeiling}`)))
-            : 0;
+        // F4 fix: guard ceiling-not-found — Math.max(0,-1) silently targets tier 0 (27b).
+        // Instead of defaulting to the largest tier, treat not-found as "no ceiling" (start=0).
+        const ceilIdx = effectiveCeiling
+            ? MODEL_TIERS.findIndex(t => t.tag.endsWith(`:${effectiveCeiling}`))
+            : -1;
+        const ceilStart = ceilIdx >= 0 ? ceilIdx : 0;
+        // Auto-evict: if the ceiling tier is installed but not warm and prism's
+        // own smaller tier models are warm, unload them to make room.
+        // Operates only on prism tier models — never evicts arbitrary Ollama models
+        // the caller doesn't own (F1). Uses an in-process mutex to prevent a
+        // concurrent request from evicting a model mid-inference (F3).
+        let freeAfterEvict = freeBytes;
+        if (loaded && loaded.size > 0) {
+            const ceilTier = MODEL_TIERS[ceilIdx >= 0 ? ceilIdx : 0];
+            const ceilName = ceilTier ? resolveOllamaName(ceilTier.tag, installed) : null;
+            const ceilInstalled = ceilName ? installed.has(ceilName) : false;
+            const ceilWarm = ceilName ? loaded.has(ceilName) : false;
+            if (ceilInstalled && !ceilWarm) {
+                // F1 fix: only count and evict prism tier models — not arbitrary warm models.
+                const tierModelsToEvict = MODEL_TIERS
+                    .map(t => resolveOllamaName(t.tag, installed))
+                    .filter(name => loaded.has(name));
+                const tierWarmBytes = tierModelsToEvict.reduce((sum, name) => {
+                    const t = MODEL_TIERS.find(t => resolveOllamaName(t.tag, installed) === name);
+                    return sum + (t ? t.weightsGb * 1024 ** 3 : 0);
+                }, 0);
+                if (freeBytes + tierWarmBytes >= ceilTier.minFreeGb * 1024 ** 3) {
+                    // F3 fix: hold eviction mutex so no concurrent request evicts a model
+                    // that another in-flight inference is actively using.
+                    const released = await _evictionMutex.acquire();
+                    try {
+                        // F2 fix: await each evict call; log failures; don't proceed blind.
+                        const evictResults = await Promise.allSettled(tierModelsToEvict.map(m => fetch(`${deps.ollamaUrl}/api/generate`, {
+                            method: "POST",
+                            body: JSON.stringify({ model: m, keep_alive: 0 }),
+                            signal: AbortSignal.timeout(3_000),
+                        })));
+                        const failed = evictResults.filter(r => r.status === "rejected").length;
+                        if (failed > 0) {
+                            debugLog(`[prism_infer] evict: ${failed}/${tierModelsToEvict.length} unload requests failed`);
+                        }
+                        // Settle: give Ollama time to release buffers before re-reading RAM.
+                        await new Promise(r => setTimeout(r, 800));
+                        freeAfterEvict = deps.freemem();
+                        debugLog(`[prism_infer] auto-evicted ${tierModelsToEvict.join(", ")} ` +
+                            `(${fmtGb(tierWarmBytes)}) → freeAfterEvict=${fmtGb(freeAfterEvict)}`);
+                        // F2 fix: if still insufficient after eviction, log and fall through
+                        // cleanly — the tier loop will emit ram_insufficient rather than
+                        // proceeding on a stale freeBytes value.
+                        if (freeAfterEvict < ceilTier.minFreeGb * 1024 ** 3) {
+                            debugLog(`[prism_infer] evict completed but RAM still insufficient for ${ceilTier.tag}`);
+                        }
+                    }
+                    finally {
+                        released();
+                    }
+                }
+            }
+        }
         let anyViable = false;
         for (let i = ceilStart; i < MODEL_TIERS.length; i++) {
             const tier = MODEL_TIERS[i];
@@ -389,7 +523,7 @@ export async function runInfer(args, deps) {
             // RAM gate — but skip the check if the tier is already warm in
             // Ollama. Reused models don't reallocate weight buffers.
             const isWarm = loaded.has(ollamaName);
-            if (!isWarm && freeBytes < tier.minFreeGb * (1024 ** 3)) {
+            if (!isWarm && freeAfterEvict < tier.minFreeGb * (1024 ** 3)) {
                 attempts.push({ tier: tier.tag, reason: "ram_insufficient" });
                 continue;
             }
@@ -400,20 +534,18 @@ export async function runInfer(args, deps) {
             if (result.ok) {
                 const { stripped, thinkOnly } = stripThink(result.text);
                 const output = stripped;
-                // Quality gate for chat/code modes
-                if (mode !== "route") {
-                    const gate = passesQualityGate(output, thinkOnly, result.doneReason);
-                    if (!gate.pass && allowCloud) {
-                        debugLog(`[prism_infer] quality gate FAIL (${gate.reason}) — escalating to cloud`);
-                        attempts.push({ tier: tier.tag, reason: `quality_gate:${gate.reason}` });
-                        if (gate.reason === "hard_truncation" || gate.reason === "loop_detected") {
-                            localDraft = { output, tier: tier.tag, promptTokens: result.promptTokens, completionTokens: result.completionTokens };
-                        }
-                        break;
-                    }
-                    if (!gate.pass) {
-                        debugLog(`[prism_infer] quality gate FAIL (${gate.reason}) — no cloud, serving local`);
+                // Quality gate — all modes. Route uses mode-aware empty floor (length===0).
+                const gate = passesQualityGate(output, thinkOnly, result.doneReason, mode);
+                if (!gate.pass && allowCloud) {
+                    debugLog(`[prism_infer] quality gate FAIL (${gate.reason}) — escalating to cloud`);
+                    attempts.push({ tier: tier.tag, reason: `quality_gate:${gate.reason}` });
+                    if (gate.reason === "hard_truncation" || gate.reason === "loop_detected") {
+                        localDraft = { output, tier: tier.tag, promptTokens: result.promptTokens, completionTokens: result.completionTokens };
                     }
+                    break;
+                }
+                if (!gate.pass) {
+                    debugLog(`[prism_infer] quality gate FAIL (${gate.reason}) — no cloud, serving local`);
                 }
                 return await applyVerification(output, gatedArgs, deps, {
                     backend: `ollama-${tier.tag.replace("prism-coder:", "")}`,
@@ -448,7 +580,9 @@ export async function runInfer(args, deps) {
                 used_cloud: true,
                 attempts,
                 plan: ent.plan,
-                prompt_tokens: Math.ceil(args.prompt.length / 4),
+                // T4: omit prompt_tokens — cloud doesn't return Ollama actual eval count.
+                // recordInference receives prompt_text and computes submittedEst via
+                // estimateTokens(), keeping promptTokensEvaluated=0 (correct for cloud).
                 completion_tokens: Math.ceil(cloud.output.length / 4),
             });
         }
@@ -524,10 +658,13 @@ export async function prismInferHandler(args) {
             callLocal: callOllamaGenerate,
             callCloud: callSynaluxInference,
             ollamaUrl: PRISM_LOCAL_LLM_URL,
+            callVerifier: SYNALUX_CONFIGURED ? callSynaluxVerifier : undefined,
         });
         debugLog(`[prism_infer] backend=${result.backend} model=${result.model_picked} latency=${result.latency_ms}ms free=${result.ram_free_mb}MB`);
         // Local accumulator — sole source of the user-facing metrics block.
-        recordInference(result);
+        // T4: pass prompt_text so recordInference computes submittedEst via
+        // estimateTokens() — critical for cloud path where prompt_tokens is unset.
+        recordInference({ ...result, prompt_text: args.prompt });
         // Best-effort portal forwarding (independent analytics stream).
         // safety_gate excluded — logging crisis filter triggers is a HIPAA concern.
         if (result.backend !== "safety_gate") {
@@ -543,7 +680,7 @@ export async function prismInferHandler(args) {
         const tokenStr = result.prompt_tokens != null || result.completion_tokens != null
             ? ` tokens=${result.prompt_tokens ?? "?"}in/${result.completion_tokens ?? "?"}out`
             : "";
-        const header = `[prism_infer] backend=${result.backend}` +
+        const headerBase = `[prism_infer] backend=${result.backend}` +
             ` model=${result.model_picked ?? "n/a"}` +
             ` plan=${result.plan ?? "unknown"}` +
             ` free_ram=${result.ram_free_mb}MB` +
@@ -553,6 +690,11 @@ export async function prismInferHandler(args) {
             (result.quality_gate_failed ? ` quality_gate_failed=true` : "") +
             (result.verification ? ` verify=${result.verification.action}` : "") +
             (result.attempts.length ? ` attempts=${JSON.stringify(result.attempts)}` : "");
+        // Append periodic session-level stats to the header line.
+        // compact=true is threshold-gated (PRISM_METRICS_EVERY, default every 5 calls)
+        // so it doesn't appear on every response — only as a rolling summary.
+        const metricsLine = formatInferenceMetrics(true);
+        const header = metricsLine ? `${headerBase}\n${metricsLine}` : headerBase;
         return {
             content: [
                 { type: "text", text: header },