prism-mcp-server 20.0.6 → 20.0.7

package/dist/tools/ledgerHandlers.js

@@ -904,14 +904,14 @@ export async function sessionLoadContextHandler(args) {
     // If the active role has a skill document stored, append it so the
     // agent loads its rules/conventions automatically at session start.
     let skillBlock = "";
-    let skillLoaded = false;
     const loadedSkills = [];
+    const skillEntries = [];
     if (effectiveRole) {
         const skillContent = await getSetting(`skill:${effectiveRole}`, "");
         if (skillContent && skillContent.trim()) {
-            skillBlock = `\n\n[📜 ROLE SKILL: ${effectiveRole}]\n${skillContent.trim()}`;
-            skillLoaded = true;
-            loadedSkills.push(effectiveRole);
+            // protected: the role skill is deliberate per-agent configuration and
+            // was unconditionally injected before budgeting existed.
+            skillEntries.push({ name: effectiveRole, content: skillContent, protected: true, category: "role", priority: -1 });
             debugLog(`[session_load_context] Injecting skill for role="${effectiveRole}" (${skillContent.length} chars)`);
         }
     }
@@ -928,14 +928,23 @@ export async function sessionLoadContextHandler(args) {
     } });
     const skillResolution = await resolveSkills(project, prompt, effectiveRole);
     // Client-renders-content: portal returns names, we load content from local DB
+    const resolvedMeta = new Map((skillResolution.skills || []).map((s) => [s.name, s]));
+    // Legacy last-good caches carry names without metadata; OFFLINE_FALLBACK
+    // membership is the floor of last resort so core rules stay inlined.
+    const { OFFLINE_FALLBACK } = await import("./skillRouting.js");
+    const fallbackFloor = new Set(OFFLINE_FALLBACK.universal.map((e) => (typeof e === "string" ? e : e.name)));
     for (const name of skillResolution.names || []) {
-        if (loadedSkills.includes(name))
+        if (skillEntries.some((e) => e.name === name))
             continue;
         const content = await getSetting(`skill:${name}`, "");
         if (content?.trim()) {
-            skillBlock += `\n\n[📜 SKILL: ${name}]\n${content.trim()}`;
-            loadedSkills.push(name);
-            skillLoaded = true;
+            const meta = resolvedMeta.get(name);
+            skillEntries.push({
+                name, content,
+                protected: meta?.protected ?? (skillResolution.isOffline && fallbackFloor.has(name)),
+                category: meta?.category ?? "universal",
+                priority: meta?.priority ?? 999,
+            });
         }
     }
     // Offline fallback: load ALL local skill: content (no tier gating).
@@ -948,16 +957,34 @@ export async function sessionLoadContextHandler(args) {
             if (!k.startsWith("skill:") || !v)
                 continue;
             const name = k.replace("skill:", "");
-            if (loadedSkills.includes(name))
+            if (skillEntries.some((e) => e.name === name))
                 continue;
             const content = v.trim();
-            if (content && content.trim()) {
-                skillBlock += '\n\n[📜 SKILL: ' + name + ']\n' + content.trim();
-                loadedSkills.push(name);
-                skillLoaded = true;
+            if (content) {
+                // Offline can't know protected flags; OFFLINE_FALLBACK names are the
+                // best available floor — mark those protected so they always inline.
+                skillEntries.push({ name, content, protected: fallbackFloor.has(name), category: "offline", priority: 999 });
             }
         }
     }
+    // ─── Skill delivery budget (local-first plan v2 Phase 1) ────
+    // Paid-tier resolution returns 30+ skills (~114KB measured). Unbudgeted
+    // inlining exceeds host tool-result caps and the whole response gets
+    // file-diverted — the agent receives NOTHING. Budgeted assembly: protected
+    // always full, prompt-matched next, tail by priority, overflow by name.
+    // 60% of the response budget: skills must not saturate the whole allowance
+    // or T5 truncation zeroes out briefing/history — the memory this tool
+    // exists to deliver. The protected floor may still exceed this tranche
+    // (always inlined); the reserved 40% keeps history alive whenever the
+    // caller's budget covers the floor at all.
+    const skillBudgetChars = maxTokens && maxTokens > 0 ? Math.floor(maxTokens * 3.5 * 0.6) : Number.POSITIVE_INFINITY;
+    const { assembleSkillBlock } = await import("../utils/skillBudget.js");
+    const budgeted = assembleSkillBlock(skillEntries, skillBudgetChars);
+    skillBlock = budgeted.block;
+    loadedSkills.push(...budgeted.inlined);
+    if (budgeted.overflow.length > 0) {
+        debugLog(`[session_load_context] skill budget: inlined ${budgeted.inlined.length}, overflow ${budgeted.overflow.length} (${skillBudgetChars} chars)`);
+    }
     // ─── Agent Greeting Block ────────────────────────────────────
     // Shows agent identity (name + role) and skill status after briefing.
     let greetingBlock = "";

package/dist/tools/prismInferHandler.js

@@ -31,6 +31,7 @@ import { passesQualityGate } from "../utils/qualityGate.js";
 import { checkInputSafety, checkOutputSafety } from "../utils/safetyGate.js";
 import { callLayer1 as defaultCallLayer1, keywordBackstop } from "../utils/layer1.js";
 import { recordInference, recordThinkOnlyRetry, formatInferenceMetrics } from "../utils/inferenceMetrics.js";
+import { appendInferMetric } from "../storage/inferMetricsLedger.js";
 // ─── Tool Definition ────────────────────────────────────────────
 export const PRISM_INFER_TOOL = {
     name: "prism_infer",
@@ -259,13 +260,42 @@ async function callOllamaGenerate(url, model, prompt, system, maxTokens, tempera
         return { ok: false, reason: name === "TimeoutError" || name === "AbortError" ? "timeout" : "network" };
     }
 }
-async function callSynaluxInference(prompt, maxTokens, timeoutMs) {
+// ─── Cloud fallback via synalux portal ─────────────────────────
+/**
+ * Typed refusal for reserved clinical content (plan v2 §5.1) — callers can
+ * distinguish "refused for safety" from infrastructure failure via
+ * `refusal_reason` instead of parsing the message. Also ledgered so refusals
+ * are visible in delegation metrics (backend='refused').
+ */
+export class ReservedRefusalError extends Error {
+    attempts;
+    refusal_reason = "layer1_reserved";
+    constructor(verdict, attempts) {
+        super(`prism_infer: Layer 1 verdict=${verdict}, reserved content refused. attempts=${JSON.stringify(attempts)}`);
+        this.attempts = attempts;
+        this.name = "ReservedRefusalError";
+    }
+}
+function makeReservedRefusal(verdict, attempts) {
+    // Ledger the refusal (fire-and-forget). No prompt content is persisted —
+    // same HIPAA posture as the safety_gate exclusion.
+    appendInferMetric({
+        backend: "refused", model: null, used_cloud: false,
+        refusal_reason: "layer1_reserved",
+    });
+    return new ReservedRefusalError(verdict, attempts);
+}
+async function callSynaluxInference(prompt, maxTokens, timeoutMs, opts) {
     if (!PRISM_SYNALUX_BASE_URL)
         return { ok: false, reason: "no_synalux_base_url" };
     const jwt = await getSynaluxJwt();
     if (!jwt)
         return { ok: false, reason: "jwt_exchange_failed" };
     const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism/inference`;
+    // reserved=true tells the portal this prompt was refused by local Layer-1
+    // as reserved clinical content: it must be served by Claude or refused —
+    // never by a small local model or OpenRouter (plan v2 §5.1).
+    const reqBody = JSON.stringify({ prompt, max_tokens: maxTokens, ...(opts?.reserved ? { reserved: true } : {}) });
     try {
         let res = await fetch(url, {
             method: "POST",
@@ -273,7 +303,7 @@ async function callSynaluxInference(prompt, maxTokens, timeoutMs) {
                 "Authorization": `Bearer ${jwt}`,
                 "Content-Type": "application/json",
             },
-            body: JSON.stringify({ prompt, max_tokens: maxTokens }),
+            body: reqBody,
             signal: AbortSignal.timeout(timeoutMs),
             redirect: "error",
         });
@@ -289,7 +319,7 @@ async function callSynaluxInference(prompt, maxTokens, timeoutMs) {
                     "Authorization": `Bearer ${fresh}`,
                     "Content-Type": "application/json",
                 },
-                body: JSON.stringify({ prompt, max_tokens: maxTokens }),
+                body: reqBody,
                 signal: AbortSignal.timeout(timeoutMs),
                 redirect: "error",
             });
@@ -433,8 +463,18 @@ export async function runInfer(args, deps) {
             attempts.push({ tier: "layer1", reason: `layer1_${l1.toLowerCase()}` });
             if (allowCloud) {
                 const cloudTimeout = args.timeout_ms ?? 90_000;
-                const cloud = await deps.callCloud(args.prompt, maxTokens, cloudTimeout);
+                const cloud = await deps.callCloud(args.prompt, maxTokens, cloudTimeout, { reserved: true });
                 if (cloud.ok && cloud.output) {
+                    // Defense in depth (§5.1): the escalation target for reserved
+                    // content must be STRONGER than the local model that refused
+                    // it. An old/unpatched portal that ignores the reserved flag
+                    // can answer from a small local tier or OpenRouter — never
+                    // serve that; refuse instead.
+                    const weakBackend = /^(ollama-|openrouter-)/.test(cloud.backend ?? "");
+                    if (weakBackend) {
+                        attempts.push({ tier: "synalux", reason: `reserved_weak_backend:${cloud.backend}` });
+                        throw makeReservedRefusal(l1, attempts);
+                    }
                     return await applyVerification(cloud.output, gatedArgs, deps, {
                         backend: cloud.backend ?? "synalux",
                         model_picked: null,
@@ -448,7 +488,7 @@ export async function runInfer(args, deps) {
                 }
                 attempts.push({ tier: "synalux", reason: cloud.reason ?? "unknown" });
             }
-            throw new Error(`prism_infer: Layer 1 verdict=${l1}, reserved content refused. attempts=${JSON.stringify(attempts)}`);
+            throw makeReservedRefusal(l1, attempts);
         }
         if (l1 === "ERROR") {
             debugLog(`[prism_infer] Layer 1 verdict=ERROR — classifier failed, trying cloud then keyword backstop`);
@@ -708,7 +748,9 @@ export async function prismInferHandler(args) {
         // Local accumulator — sole source of the user-facing metrics block.
         // 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 });
+        // mode lives on args, not the result — pass it explicitly or the
+        // ledger's mode column is silently NULL forever.
+        recordInference({ ...result, prompt_text: args.prompt, mode: args.mode ?? "route" });
         // Best-effort session telemetry — records that inference ran for this
         // conversation. Never affects routing or safety decisions.
         const _convId = args.conversation_id;

package/dist/tools/projects.js

@@ -0,0 +1,214 @@
+/**
+ * Prism Projects — MCP Tool Handlers (Phase 4)
+ * ===============================================
+ *
+ * CRUD operations for projects and team membership.
+ * Tier limits enforced via getCloudLimits().
+ *
+ * Tools:
+ *   - project_create: Create a new project
+ *   - project_list: List all projects for current user
+ *   - project_update: Update project name/description/status
+ *   - project_delete: Archive/delete a project
+ *   - project_assign_member: Add a member to a project
+ *   - project_remove_member: Remove a member from a project
+ */
+import { randomUUID } from 'crypto';
+import { getStorage } from '../storage/index.js';
+import { getCloudLimits } from '../prism-cloud.js';
+import { PRISM_USER_ID } from '../config.js';
+const VALID_STATUSES = ['draft', 'active', 'on_hold', 'completed', 'archived'];
+const VALID_ROLES = ['owner', 'editor', 'viewer'];
+// Tier limits for projects
+const PROJECT_LIMITS = {
+    free: { maxProjects: 1, maxMembers: 1 },
+    standard: { maxProjects: 9, maxMembers: 5 },
+    advanced: { maxProjects: 999, maxMembers: 25 },
+    enterprise: { maxProjects: 999999, maxMembers: 999999 },
+};
+function makeResult(text, isError = false) {
+    return { content: [{ type: 'text', text }], isError };
+}
+// ─── project_create ──────────────────────────────────────────
+export async function projectCreateHandler(args) {
+    const { name, description, status, team_id } = args;
+    if (!name || typeof name !== 'string' || name.trim().length === 0) {
+        return makeResult('❌ Missing required field: name', true);
+    }
+    if (status && !VALID_STATUSES.includes(status)) {
+        return makeResult(`❌ Invalid status. Must be one of: ${VALID_STATUSES.join(', ')}`, true);
+    }
+    // Check tier limits
+    const limits = getCloudLimits();
+    const tierLimits = PROJECT_LIMITS[limits.tier] || PROJECT_LIMITS.free;
+    const storage = await getStorage();
+    const db = storage.db;
+    if (!db) {
+        return makeResult('❌ Project management requires SQLite storage.', true);
+    }
+    // Count existing projects
+    const countResult = await db.execute({
+        sql: 'SELECT COUNT(*) as cnt FROM prism_projects WHERE created_by = ?',
+        args: [PRISM_USER_ID],
+    });
+    const currentCount = Number(countResult.rows[0]?.cnt || 0);
+    if (currentCount >= tierLimits.maxProjects) {
+        return makeResult(`❌ Project limit reached (${currentCount}/${tierLimits.maxProjects}). ` +
+            `Upgrade your plan to create more projects.`, true);
+    }
+    const id = randomUUID();
+    await db.execute({
+        sql: `INSERT INTO prism_projects (id, name, description, status, created_by, team_id)
+              VALUES (?, ?, ?, ?, ?, ?)`,
+        args: [id, name.trim(), description || '', status || 'draft', PRISM_USER_ID, team_id || null],
+    });
+    // Auto-assign creator as owner
+    await db.execute({
+        sql: `INSERT INTO prism_project_members (project_id, user_id, role)
+              VALUES (?, ?, 'owner')`,
+        args: [id, PRISM_USER_ID],
+    });
+    return makeResult(`✅ Project created: "${name.trim()}" (${id})\n` +
+        `   Status: ${status || 'draft'}\n` +
+        `   Projects used: ${currentCount + 1}/${tierLimits.maxProjects}`);
+}
+// ─── project_list ────────────────────────────────────────────
+export async function projectListHandler(args) {
+    const storage = await getStorage();
+    const db = storage.db;
+    if (!db) {
+        return makeResult('❌ Project management requires SQLite storage.', true);
+    }
+    let sql = `SELECT p.*, m.role as my_role
+               FROM prism_projects p
+               LEFT JOIN prism_project_members m ON p.id = m.project_id AND m.user_id = ?
+               WHERE (p.created_by = ? OR m.user_id = ?)`;
+    const sqlArgs = [PRISM_USER_ID, PRISM_USER_ID, PRISM_USER_ID];
+    if (args.status) {
+        sql += ` AND p.status = ?`;
+        sqlArgs.push(args.status);
+    }
+    if (args.team_id) {
+        sql += ` AND p.team_id = ?`;
+        sqlArgs.push(args.team_id);
+    }
+    sql += ` ORDER BY p.updated_at DESC`;
+    const result = await db.execute({ sql, args: sqlArgs });
+    const projects = result.rows;
+    if (projects.length === 0) {
+        return makeResult('📁 No projects found. Use `project_create` to create one.');
+    }
+    const lines = projects.map((p) => {
+        const statusIcon = p.status === 'active' ? '🟢' : p.status === 'draft' ? '📝' : p.status === 'completed' ? '✅' : p.status === 'archived' ? '📦' : '⏸️';
+        return `${statusIcon} **${p.name}** (${p.id.substring(0, 8)})\n   Status: ${p.status} | Role: ${p.my_role || 'owner'} | Updated: ${p.updated_at}`;
+    });
+    const limits = getCloudLimits();
+    const tierLimits = PROJECT_LIMITS[limits.tier] || PROJECT_LIMITS.free;
+    return makeResult(`📁 **Projects** (${projects.length}/${tierLimits.maxProjects})\n\n` +
+        lines.join('\n\n'));
+}
+// ─── project_update ──────────────────────────────────────────
+export async function projectUpdateHandler(args) {
+    const { project_id, name, description, status } = args;
+    if (!project_id) {
+        return makeResult('❌ Missing required field: project_id', true);
+    }
+    if (status && !VALID_STATUSES.includes(status)) {
+        return makeResult(`❌ Invalid status. Must be one of: ${VALID_STATUSES.join(', ')}`, true);
+    }
+    const storage = await getStorage();
+    const db = storage.db;
+    if (!db)
+        return makeResult('❌ Project management requires SQLite storage.', true);
+    const sets = ["updated_at = datetime('now')"];
+    const sqlArgs = [];
+    if (name) {
+        sets.push('name = ?');
+        sqlArgs.push(name.trim());
+    }
+    if (description !== undefined) {
+        sets.push('description = ?');
+        sqlArgs.push(description);
+    }
+    if (status) {
+        sets.push('status = ?');
+        sqlArgs.push(status);
+    }
+    sqlArgs.push(project_id);
+    await db.execute({
+        sql: `UPDATE prism_projects SET ${sets.join(', ')} WHERE id = ?`,
+        args: sqlArgs,
+    });
+    return makeResult(`✅ Project ${project_id.substring(0, 8)} updated.`);
+}
+// ─── project_delete ──────────────────────────────────────────
+export async function projectDeleteHandler(args) {
+    const { project_id, hard } = args;
+    if (!project_id) {
+        return makeResult('❌ Missing required field: project_id', true);
+    }
+    const storage = await getStorage();
+    const db = storage.db;
+    if (!db)
+        return makeResult('❌ Project management requires SQLite storage.', true);
+    if (hard) {
+        await db.execute({ sql: 'DELETE FROM prism_projects WHERE id = ?', args: [project_id] });
+        return makeResult(`🗑️ Project ${project_id.substring(0, 8)} permanently deleted.`);
+    }
+    else {
+        await db.execute({
+            sql: `UPDATE prism_projects SET status = 'archived', updated_at = datetime('now') WHERE id = ?`,
+            args: [project_id],
+        });
+        return makeResult(`📦 Project ${project_id.substring(0, 8)} archived.`);
+    }
+}
+// ─── project_assign_member ───────────────────────────────────
+export async function projectAssignMemberHandler(args) {
+    const { project_id, user_id, role } = args;
+    if (!project_id || !user_id) {
+        return makeResult('❌ Missing required fields: project_id, user_id', true);
+    }
+    const effectiveRole = role || 'viewer';
+    if (!VALID_ROLES.includes(effectiveRole)) {
+        return makeResult(`❌ Invalid role. Must be one of: ${VALID_ROLES.join(', ')}`, true);
+    }
+    // Check tier limits
+    const limits = getCloudLimits();
+    const tierLimits = PROJECT_LIMITS[limits.tier] || PROJECT_LIMITS.free;
+    const storage = await getStorage();
+    const db = storage.db;
+    if (!db)
+        return makeResult('❌ Project management requires SQLite storage.', true);
+    const countResult = await db.execute({
+        sql: 'SELECT COUNT(*) as cnt FROM prism_project_members WHERE project_id = ?',
+        args: [project_id],
+    });
+    const currentMembers = Number(countResult.rows[0]?.cnt || 0);
+    if (currentMembers >= tierLimits.maxMembers) {
+        return makeResult(`❌ Member limit reached (${currentMembers}/${tierLimits.maxMembers}). ` +
+            `Upgrade your plan to add more members.`, true);
+    }
+    await db.execute({
+        sql: `INSERT OR REPLACE INTO prism_project_members (project_id, user_id, role)
+              VALUES (?, ?, ?)`,
+        args: [project_id, user_id, effectiveRole],
+    });
+    return makeResult(`✅ ${user_id} assigned as ${effectiveRole} to project ${project_id.substring(0, 8)}.`);
+}
+// ─── project_remove_member ───────────────────────────────────
+export async function projectRemoveMemberHandler(args) {
+    const { project_id, user_id } = args;
+    if (!project_id || !user_id) {
+        return makeResult('❌ Missing required fields: project_id, user_id', true);
+    }
+    const storage = await getStorage();
+    const db = storage.db;
+    if (!db)
+        return makeResult('❌ Project management requires SQLite storage.', true);
+    await db.execute({
+        sql: 'DELETE FROM prism_project_members WHERE project_id = ? AND user_id = ?',
+        args: [project_id, user_id],
+    });
+    return makeResult(`✅ ${user_id} removed from project ${project_id.substring(0, 8)}.`);
+}

package/dist/tools/sessionMemoryDefinitions.js

@@ -1818,12 +1818,19 @@ export function isVerifyBehaviorArgs(a) {
 // ─── v19.2: Inference Metrics Tool ──────────────────────────
 export const INFERENCE_METRICS_TOOL = {
     name: "inference_metrics",
-    description: "Returns the current session's local-model inference metrics — call count, " +
-        "local vs cloud split, token totals, per-model breakdown, and average latency. " +
-        "Read-only, no arguments. Reflects prism_infer delegation usage only, not the " +
-        "host model's (Claude's) own token spend (use /cost for that).",
+    description: "Returns local-model inference metrics — call count, local vs cloud split, " +
+        "token totals, per-model breakdown, and average latency. Reflects prism_infer " +
+        "delegation usage only, not the host model's (Claude's) own token spend " +
+        "(use /cost for that). period: 'session' (default, in-memory since server " +
+        "start) or 'all' (persisted ledger across restarts).",
     inputSchema: {
         type: "object",
-        properties: {},
+        properties: {
+            period: {
+                type: "string",
+                enum: ["session", "all"],
+                description: "Metrics window: 'session' (this server process) or 'all' (durable ledger).",
+            },
+        },
     },
 };

package/dist/tools/skillRouting.js

@@ -4,9 +4,9 @@
  * Cache: keyed on (project,prompt,role), 5-min live / 30s failure.
  * Offline: last-good from local DB, or empty with warning.
  */
+import { getSynaluxJwt, invalidateSynaluxJwt } from '../utils/synaluxJwt.js';
 // -- Constants ----------------------------------------------------------------
 const SYNALUX_BASE = process.env.SYNALUX_BASE_URL || 'https://synalux.ai';
-const SKILLS_TOKEN = process.env.PRISM_SKILLS_TOKEN || '';
 const LIVE_TTL = 5 * 60 * 1000;
 const FAIL_TTL = 30_000;
 const DEFAULT_UL = { enabled: false, key_prefix: 'user_skill:' };
@@ -20,6 +20,24 @@ export const OFFLINE_FALLBACK = {
     projects: {},
     user_local: DEFAULT_UL,
 };
+/**
+ * Map a portal response to ResolvedSkill[]. Uses the portal's per-skill
+ * metadata when present; for older portals that send names only, falls back
+ * to neutral defaults (protected:false) — the budgeting floor then relies on
+ * the caller's own knowledge (e.g. OFFLINE_FALLBACK). NEVER fabricate
+ * protected:true here: an over-broad floor would defeat budgeting entirely.
+ */
+function toResolvedSkills(resp) {
+    if (resp.skills && resp.skills.length > 0) {
+        return resp.skills.map((s) => ({
+            name: s.name, priority: s.priority, protected: s.protected,
+            category: s.category ?? 'universal',
+        }));
+    }
+    return resp.loaded.map((name, i) => ({
+        name, priority: i, protected: false, category: 'universal',
+    }));
+}
 const cache = new Map();
 const inflightMap = new Map();
 function cacheKey(project, prompt) {
@@ -43,12 +61,45 @@ async function callPortal(project, prompt, role) {
             'Content-Type': 'application/json',
             'Accept': 'application/json',
         };
-        if (SKILLS_TOKEN)
-            headers['Authorization'] = `Bearer ${SKILLS_TOKEN}`;
-        const res = await fetch(`${SYNALUX_BASE}/api/v1/prism/resolve`, {
+        // Auth precedence: static PRISM_SKILLS_TOKEN (legacy/CI) → JWT exchanged
+        // from the synalux API key. The JWT path uses the same per-user identity
+        // as inference, so skills and inference resolve the SAME tier — without
+        // it, machines with only PRISM_SYNALUX_API_KEY silently resolve tier=free
+        // and never receive unprotected/prompt-routed skills.
+        const staticToken = process.env.PRISM_SKILLS_TOKEN || '';
+        let usedJwt = false;
+        if (staticToken) {
+            headers['Authorization'] = `Bearer ${staticToken}`;
+        }
+        else {
+            // Bound the exchange so a hanging JWT endpoint cannot stall
+            // session_load_context startup: after 4s proceed unauthenticated
+            // (free-tier resolve) — the exchange keeps running and its cached
+            // result authenticates the next call.
+            const jwt = await Promise.race([
+                getSynaluxJwt(),
+                new Promise((r) => setTimeout(r, 4_000, null)),
+            ]);
+            if (jwt) {
+                headers['Authorization'] = `Bearer ${jwt}`;
+                usedJwt = true;
+            }
+        }
+        const doFetch = () => fetch(`${SYNALUX_BASE}/api/v1/prism/resolve`, {
             method: 'POST', headers, body: JSON.stringify(body),
             signal: AbortSignal.timeout(5_000),
+            redirect: 'error', // never follow a redirect with a credential attached
         });
+        let res = await doFetch();
+        if (res.status === 401 && usedJwt) {
+            // Expired/rotated JWT — invalidate and retry once with a fresh one.
+            invalidateSynaluxJwt();
+            const fresh = await getSynaluxJwt();
+            if (fresh) {
+                headers['Authorization'] = `Bearer ${fresh}`;
+                res = await doFetch();
+            }
+        }
         if (!res.ok)
             throw new Error(`HTTP ${res.status}`);
         return (await res.json());
@@ -92,9 +143,7 @@ export async function resolveSkills(project, prompt, role) {
     if (cached) {
         return {
             names: cached.resp.loaded,
-            skills: cached.resp.loaded.map((name, i) => ({
-                name, priority: i, protected: false, category: 'universal',
-            })),
+            skills: toResolvedSkills(cached.resp),
             user_local: DEFAULT_UL,
             isOffline: !cached.live,
             routing_version: cached.resp.routing_version,
@@ -107,7 +156,7 @@ export async function resolveSkills(project, prompt, role) {
             if (stored) {
                 const resp = JSON.parse(stored);
                 return {
-                    names: resp.loaded, skills: [], user_local: DEFAULT_UL,
+                    names: resp.loaded, skills: toResolvedSkills(resp), user_local: DEFAULT_UL,
                     isOffline: true,
                     routing_version: resp.routing_version,
                 };