prism-mcp-server 20.5.0 → 20.5.2

package/dist/server.js

@@ -324,7 +324,9 @@ export const PRISM_SERVER_INSTRUCTIONS = `Prism MCP — The Mind Palace for AI A
     `prompt_keywords ON-DEVICE to load symptom-triggered skills on turn one; it is used for routing ` +
     `only and never leaves the machine. Pass {} only when there is no user message. ` +
     `When the startup display lists "Symptom-triggered skills", those skills matched the first message's ` +
-    `trigger rules — read them before proposing any change. Surfacing a name is not loading it. ` +
+    `trigger rules — read each before proposing any change. Surfacing a name is not loading it: hosts that ` +
+    `do not auto-load skill files must fetch each body with knowledge_search, passing the skill name ` +
+    `exactly as listed. ` +
     `Emit no preamble. Print the complete tool result verbatim as the entire first-turn startup display, before any optional ` +
     `answer. Do not summarize, paraphrase, rename headings, reformat, or omit any returned section. Preserve its order and ` +
     `line content. For a greeting-only prompt, stop after the verbatim startup display. ` +

package/dist/skillManifestSync.js

@@ -386,9 +386,33 @@ async function enforceNativeEntitlements(incomingNames, agentsSkillsDir) {
         await quarantineManagedSkill(target, name, agentsSkillsDir);
     }
 }
+/**
+ * The cross-host canonical skills root — single source of truth.
+ *
+ * Do NOT re-derive this path anywhere else. It is overridable per caller
+ * (`agentsSkillsDir`) and per home (`homeDir`), so a literal copied into
+ * another module is wrong on any machine that overrides either.
+ */
+export function resolveCanonicalSkillsDir(options = {}) {
+    return options.agentsSkillsDir ?? join(options.homeDir ?? homedir(), ".agents", "skills");
+}
+/**
+ * Read a skill's body from the canonical root. Returns null when absent or
+ * unreadable — callers must degrade, never fail startup over it.
+ */
+export async function readNativeSkillBody(name, options = {}) {
+    if (!SAFE_NAME.test(name))
+        return null; // no traversal via name
+    try {
+        return await readFile(join(resolveCanonicalSkillsDir(options), name, "SKILL.md"), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
 async function resolveNativeSkillsDirs(options) {
     const userHome = options.homeDir ?? homedir();
-    const canonical = options.agentsSkillsDir ?? join(userHome, ".agents", "skills");
+    const canonical = resolveCanonicalSkillsDir(options);
     let claudeCode = null;
     let cursor = null;
     if (typeof options.claudeCodeSkillsDir === "string") {

package/dist/tools/ledgerHandlers.js

@@ -86,6 +86,60 @@ const MEMORY_BOUNDARY_SUFFIX = '\n</prism_memory>';
  * budget — an unbounded list would starve the context it is meant to annotate.
  */
 const MAX_SYMPTOM_SKILLS = 5;
+/**
+ * Hard ceiling on the inlined skill body, and the share of the display budget
+ * it may take. Naming a skill is not delivering it: skill bodies reach agents
+ * ONLY as files under resolveNativeSkillsDirs, and hosts outside that list
+ * (Gemini) have no path to the content at all — no MCP tool serves it. Three
+ * instruction rewrites failed for that reason before it was found. Inlining
+ * removes the indirection entirely: the rule is simply in context.
+ */
+const SYMPTOM_SKILL_INLINE_MAX = 1_800;
+const SYMPTOM_SKILL_BUDGET_SHARE = 0.4;
+/** Below this the inlined rule is too clipped to be worth the space it costs. */
+const SYMPTOM_SKILL_INLINE_MIN = 400;
+/**
+ * The character budget a native startup display will actually be capped to.
+ *
+ * Single source of truth: capNativeStartupText caps against this, and the
+ * inlined rule is sized from it. Sizing the rule from the LEVEL constant
+ * instead let the suffix exceed the whole allowance — bootstrap divides the
+ * budget across rendered projects, so a per-project slice of 512 against an
+ * 1,800-char exempt suffix produced a 1,919-char display (275% over) with the
+ * session context entirely gone. The suffix is truncation-exempt by design;
+ * that only works if it is sized against the real budget.
+ */
+function effectiveNativeBudget(level, requestedMaxChars) {
+    const configuredLimit = NATIVE_STARTUP_MAX_CHARS[level];
+    return Math.max(512, Math.min(configuredLimit, requestedMaxChars ?? configuredLimit));
+}
+// Skill bodies are read via skillManifestSync.readNativeSkillBody, which owns
+// the canonical root. That path is overridable per caller and per home, so a
+// literal copied to this module would be wrong on any machine that overrides
+// either — and would silently drift from the writer.
+/**
+ * Drop the YAML frontmatter before inlining.
+ *
+ * `name`/`description`/`metadata` are routing and authoring metadata — the
+ * agent already has the name from the line above, and the rest is provenance.
+ * Measured at ~161 chars on data-before-code, which is what pushed the
+ * Anti-Patterns list past the cap and truncated it mid-word. Every character
+ * here is taken from the rule it is supposed to deliver.
+ *
+ * Returns "" for absent input so the caller's single truthiness check covers
+ * both "no body" and "frontmatter only".
+ */
+function stripSkillFrontmatter(raw) {
+    const text = (raw ?? "").trim();
+    if (!text.startsWith("---"))
+        return text;
+    // Closing fence must be its own line; a body line of "---" mid-document is
+    // not a terminator, so anchor on the newline pair.
+    const end = text.indexOf("\n---", 3);
+    if (end === -1)
+        return text; // unterminated frontmatter — inline as-is
+    return text.slice(text.indexOf("\n", end + 1) + 1).trim();
+}
 const NATIVE_STARTUP_MAX_CHARS = {
     quick: 4_000,
     standard: 8_000,
@@ -252,8 +306,7 @@ async function buildNativeSystemReadyBlock(snapshot, depth) {
         `> - 🔄 **Skill sync:** ${SKILL_SYNC_STATUS_LABELS[snapshot.syncStatus]} · committed manifest${conflictSuffix}`;
 }
 function capNativeStartupText(text, level, requestedMaxChars, suffix = "") {
-    const configuredLimit = NATIVE_STARTUP_MAX_CHARS[level];
-    const maxChars = Math.max(512, Math.min(configuredLimit, requestedMaxChars ?? configuredLimit));
+    const maxChars = effectiveNativeBudget(level, requestedMaxChars);
     if (text.length + suffix.length <= maxChars)
         return text + suffix;
     const marker = `\n\n… Additional ${level} context omitted to keep native startup within its display budget.`;
@@ -1262,9 +1315,32 @@ export async function sessionLoadContextHandler(args, options = {}) {
                     const overflow = matched.length - shown.length;
                     // Imperative, not a label: a bare list is decorative, and nothing
                     // else in the pipeline tells the agent to act on it.
+                    // Names are interpolated, never a placeholder. A `<skill name>`
+                    // placeholder here rendered as knowledge_search("") on a real host —
+                    // markdown/HTML display ate the angle brackets as an unknown tag.
+                    // Never emit angle brackets in text a host will render.
                     symptomSkillSuffix = `\n\n**Symptom-triggered skills:** ${shown.join(", ")}` +
                         (overflow > 0 ? `, … ${overflow} more` : "") +
-                        `\nThe first message matches these skills' trigger rules. Read them before proposing changes.\n`;
+                        `\nThe first message matches these skills' trigger rules. Follow them before ` +
+                        `proposing any change.\n`;
+                    // INLINE the top match's body rather than pointing at it. Naming a
+                    // skill is not delivering it: bodies reach agents only as files under
+                    // the canonical root, and hosts outside that mirror have no path to
+                    // the content — no MCP tool serves it. Three instruction rewrites
+                    // failed on that gap. Inlining removes the indirection entirely.
+                    const { readNativeSkillBody } = await import("../skillManifestSync.js");
+                    const body = stripSkillFrontmatter(await readNativeSkillBody(shown[0]));
+                    // Size against the budget this display will ACTUALLY be capped to,
+                    // not the level constant — bootstrap divides it across projects.
+                    const cap = Math.min(SYMPTOM_SKILL_INLINE_MAX, Math.floor(effectiveNativeBudget(level, options.nativeMaxChars) * SYMPTOM_SKILL_BUDGET_SHARE));
+                    // Too tight to carry a useful rule: keep the name line, which is
+                    // small, and leave the remaining budget to the session context.
+                    if (body && cap >= SYMPTOM_SKILL_INLINE_MIN) {
+                        const clipped = body.length > cap
+                            ? `${body.slice(0, cap).trimEnd()}\n… (rule truncated to fit the startup budget)`
+                            : body;
+                        symptomSkillSuffix += `\n--- ${shown[0]} ---\n${clipped}\n`;
+                    }
                 }
             }
             catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.5.0",
+  "version": "20.5.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 or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",