prism-mcp-server 20.5.1 → 20.5.3

package/dist/tools/graphHandlers.js

@@ -268,6 +268,16 @@ export async function knowledgeSearchHandler(args) {
     if (data.results && Array.isArray(data.results) && data.results.length > 0) {
         const evidenceSnippets = data.results.map((r, i) => ({
             source: `knowledge_search:${r.id ?? i}`,
+            // Carry the record date. Without it a two-year-old note and yesterday's
+            // are indistinguishable in the grounding evidence, so a stale memory is
+            // cited with the same confidence as a fresh one — local storage removes
+            // the external correction pressure that would otherwise catch it.
+            // session_date first: it is when the work HAPPENED, which is what a
+            // staleness signal needs. created_at is when the row was written and is
+            // assigned on save — it cannot be backdated, so an import would stamp
+            // every migrated memory as brand new, failing silently toward "fresh".
+            // sqlite.ts already treats session_date as authoritative.
+            recorded: r.session_date ?? r.created_at ?? r.updated_at ?? r.timestamp ?? undefined,
             content: (r.content ?? r.summary ?? r.text ?? "").slice(0, 1000),
         })).filter((s) => s.content);
         if (evidenceSnippets.length > 0) {
@@ -624,6 +634,7 @@ export async function sessionSearchMemoryHandler(args) {
         {
             const evidenceSnippets = results.map((r, i) => ({
                 source: `session_search_memory:${r.id ?? i}`,
+                recorded: r.session_date ?? r.created_at ?? r.updated_at ?? r.timestamp ?? undefined,
                 content: (r.summary ?? "").slice(0, 1000),
             })).filter((s) => s.content);
             if (evidenceSnippets.length > 0) {

package/dist/tools/ledgerHandlers.js

@@ -96,10 +96,50 @@ const MAX_SYMPTOM_SKILLS = 5;
  */
 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,
@@ -266,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.`;
@@ -1290,9 +1329,13 @@ export async function sessionLoadContextHandler(args, options = {}) {
                     // 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 = (await readNativeSkillBody(shown[0]))?.trim();
-                    if (body) {
-                        const cap = Math.min(SYMPTOM_SKILL_INLINE_MAX, Math.floor(NATIVE_STARTUP_MAX_CHARS[level] * SYMPTOM_SKILL_BUDGET_SHARE));
+                    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;

package/dist/tools/queryMemoryNaturalHandler.js

@@ -55,7 +55,7 @@ const GROUNDED_SYNTHESIS_SYSTEM = "Answer the user's question using only the sup
     "For clinical or behavioral topics, provide educational candidates for credentialed review, " +
     "not individualized treatment instructions or professional sign-off. " +
     "If the evidence is insufficient, say exactly what is missing instead of guessing.";
-function extractMemorySources(result) {
+export function extractMemorySources(result) {
     if (result.isError) {
         throw new Error(result.content[0]?.text || "knowledge_search failed");
     }
@@ -82,6 +82,7 @@ function extractMemorySources(result) {
             sources.push({
                 type: "memory",
                 source: snippet.source,
+                recorded: typeof snippet.recorded === "string" ? snippet.recorded : undefined,
                 content: snippet.content.slice(0, MAX_EVIDENCE_CHARS),
             });
         }
@@ -224,13 +225,49 @@ const DEFAULT_DEPS = {
 function toEvidence(sources) {
     return sources.map(({ source, content }) => ({ source, content }));
 }
-function buildGroundedEvidenceContext(sources) {
+/**
+ * SQLite `CURRENT_TIMESTAMP` writes "YYYY-MM-DD HH:MM:SS" in UTC with no zone,
+ * and `Date.parse` reads a zone-less stamp as LOCAL time. West of UTC that puts
+ * a ten-minute-old record hours in the FUTURE, which the guard above then hid
+ * entirely — the age disappeared exactly when the memory was freshest. Formats
+ * are not uniform across tables (semantic_knowledge writes ISO+Z, memory_links
+ * does not), so normalise rather than assume.
+ */
+function parseRecordedAt(raw) {
+    const zoneless = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
+    return Date.parse(zoneless.test(raw) ? `${raw.replace(" ", "T")}Z` : raw);
+}
+/**
+ * " (recorded 2026-08-02, 431 days ago)" — or "" when the store gave no date.
+ * Never guesses: an absent date stays absent rather than defaulting to now,
+ * which would make the oldest memories look freshest.
+ */
+export function describeAge(source) {
+    const recorded = source.type === "memory" ? source.recorded : undefined;
+    if (!recorded)
+        return "";
+    const at = parseRecordedAt(recorded);
+    if (Number.isNaN(at))
+        return "";
+    const elapsed = Date.now() - at;
+    // Tolerate clock skew between machines: slightly-future stamps are "today",
+    // not silence. Only a stamp more than a day ahead is treated as bad data.
+    if (elapsed < -86_400_000)
+        return "";
+    const days = Math.max(0, Math.floor(elapsed / 86_400_000));
+    const day = recorded.slice(0, 10);
+    return days === 0 ? ` (recorded ${day}, today)` : ` (recorded ${day}, ${days} days ago)`;
+}
+export function buildGroundedEvidenceContext(sources) {
     let remaining = MAX_SYNTHESIS_EVIDENCE_CHARS;
     const evidenceBlocks = [];
     for (const [index, source] of sources.entries()) {
         if (remaining <= 0)
             break;
-        const label = `[SOURCE ${index + 1}: ${source.source}]`;
+        // Age belongs in the label, not just the payload. An undated fragment
+        // cannot be reasoned about; a fragment labelled two years old can be
+        // weighed against fresher evidence or challenged outright.
+        const label = `[SOURCE ${index + 1}: ${source.source}${describeAge(source)}]`;
         const availableForContent = Math.max(0, remaining - label.length - 1);
         if (availableForContent === 0)
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.5.1",
+  "version": "20.5.3",
   "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",