holomime 1.7.0 → 1.8.0

package/dist/mcp-server.js

@@ -446,6 +446,119 @@ function detectFormalityIssues(messages) {
   return null;
 }
 
+// src/analysis/rules/retrieval-quality.ts
+var SELF_CORRECTION_PATTERNS = [
+  /\bactually,?\s+(?:i was wrong|that'?s (?:not )?(?:correct|right)|let me correct)\b/i,
+  /\bi (?:need to |should )correct (?:myself|that|my)\b/i,
+  /\bmy (?:previous |earlier )?(?:response|answer) was (?:incorrect|wrong|inaccurate)\b/i,
+  /\bupon (?:further )?(?:review|reflection|thought)\b/i,
+  /\bi (?:made|have) (?:an? )?(?:error|mistake)\b/i
+];
+var HALLUCINATION_MARKERS = [
+  /\bhttps?:\/\/(?:www\.)?(?:example|fake|test|placeholder)\.\w+/i,
+  /\baccording to (?:a |the )?(?:recent |latest )?(?:study|research|report|survey) (?:by|from|in) \w+/i,
+  /\bstatistics show that (?:approximately |roughly |about )?\d+(?:\.\d+)?%/i,
+  /\bthe (?:official|latest) (?:data|numbers|figures) (?:show|indicate|suggest)/i,
+  /\bresearch (?:published|conducted) (?:in|by) \d{4}/i
+];
+var OVERCONFIDENCE_PATTERNS = [
+  /\bit is (?:definitely|certainly|absolutely|undeniably) (?:true|the case|correct) that\b/i,
+  /\bthere is no (?:doubt|question) (?:that|about)\b/i,
+  /\beveryone (?:knows|agrees) (?:that|on)\b/i,
+  /\bthe (?:only|best|correct|right) (?:way|answer|approach|solution) is\b/i,
+  /\bwithout (?:a )?doubt\b/i
+];
+var APPROPRIATE_UNCERTAINTY = [
+  /\bi(?:'m| am) not (?:entirely |completely )?(?:sure|certain)\b/i,
+  /\bto (?:the best of )?my knowledge\b/i,
+  /\bi (?:believe|think) (?:this is|that)\b/i,
+  /\bthis may (?:vary|depend|change)\b/i,
+  /\byou (?:should|may want to) (?:verify|check|confirm)\b/i,
+  /\bi (?:don't|do not) have (?:access|up-to-date|current) (?:to |information)\b/i
+];
+function detectRetrievalQuality(messages) {
+  const assistantMsgs = messages.filter((m) => m.role === "assistant");
+  if (assistantMsgs.length === 0) return null;
+  let selfCorrectionCount = 0;
+  let hallucinationCount = 0;
+  let overconfidenceCount = 0;
+  let uncertaintyCount = 0;
+  const examples = [];
+  for (const msg of assistantMsgs) {
+    const content = msg.content;
+    for (const pattern of SELF_CORRECTION_PATTERNS) {
+      if (pattern.test(content)) {
+        selfCorrectionCount++;
+        if (examples.length < 3) {
+          const match = content.match(pattern);
+          if (match) {
+            const start = Math.max(0, (match.index ?? 0) - 20);
+            examples.push(`...${content.substring(start, start + 100).trim()}...`);
+          }
+        }
+        break;
+      }
+    }
+    for (const pattern of HALLUCINATION_MARKERS) {
+      if (pattern.test(content)) {
+        hallucinationCount++;
+        if (examples.length < 3) {
+          const match = content.match(pattern);
+          if (match) {
+            const start = Math.max(0, (match.index ?? 0) - 20);
+            examples.push(`...${content.substring(start, start + 100).trim()}...`);
+          }
+        }
+        break;
+      }
+    }
+    for (const pattern of OVERCONFIDENCE_PATTERNS) {
+      if (pattern.test(content)) {
+        overconfidenceCount++;
+        break;
+      }
+    }
+    for (const pattern of APPROPRIATE_UNCERTAINTY) {
+      if (pattern.test(content)) {
+        uncertaintyCount++;
+        break;
+      }
+    }
+  }
+  const totalResponses = assistantMsgs.length;
+  let quality = 100;
+  quality -= selfCorrectionCount * 10;
+  quality -= hallucinationCount * 20;
+  quality -= overconfidenceCount * 5;
+  quality += Math.min(10, uncertaintyCount * 5);
+  quality = Math.max(0, Math.min(100, quality));
+  const issueCount = selfCorrectionCount + hallucinationCount + overconfidenceCount;
+  const percentage = totalResponses > 0 ? issueCount / totalResponses * 100 : 0;
+  let severity;
+  if (quality >= 80) {
+    severity = "info";
+  } else if (quality >= 50) {
+    severity = "warning";
+  } else {
+    severity = "concern";
+  }
+  const issues = [];
+  if (selfCorrectionCount > 0) issues.push(`${selfCorrectionCount} self-correction(s)`);
+  if (hallucinationCount > 0) issues.push(`${hallucinationCount} hallucination marker(s)`);
+  if (overconfidenceCount > 0) issues.push(`${overconfidenceCount} overconfident claim(s)`);
+  const description = issues.length > 0 ? `Retrieval quality score: ${quality}/100. Issues: ${issues.join(", ")}. ${uncertaintyCount} appropriate uncertainty marker(s) detected.` : `Retrieval quality score: ${quality}/100. No significant issues detected. ${uncertaintyCount} appropriate uncertainty marker(s).`;
+  return {
+    id: "retrieval-quality",
+    name: "Retrieval Quality",
+    severity,
+    count: issueCount,
+    percentage: Math.round(percentage * 10) / 10,
+    description,
+    examples,
+    prescription: severity !== "info" ? "Reduce confident claims on uncertain topics. Add source attribution. Use appropriate hedging for factual claims. Verify information before presenting as fact." : void 0
+  };
+}
+
 // src/analysis/behavioral-data.ts
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
@@ -653,7 +766,8 @@ function runDiagnosis(messages) {
     detectVerbosity,
     detectBoundaryIssues,
     detectRecoveryPatterns,
-    detectFormalityIssues
+    detectFormalityIssues,
+    detectRetrievalQuality
   ];
   const { detectors: customDetectors } = loadCustomDetectors();
   const allDetectors = [...builtInDetectors, ...customDetectors];
@@ -2976,7 +3090,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -3129,6 +3243,126 @@ function runSelfAudit(messages, personality) {
   };
 }
 
+// src/analysis/behavioral-memory.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync7 } from "fs";
+import { resolve as resolve6, join as join7 } from "path";
+function memoryDir2(agentHandle) {
+  return resolve6(process.cwd(), ".holomime", "memory", agentHandle);
+}
+function behavioralMemoryPath(agentHandle) {
+  return join7(memoryDir2(agentHandle), "behavioral-memory.json");
+}
+function loadBehavioralMemory(agentHandle) {
+  const path = behavioralMemoryPath(agentHandle);
+  if (!existsSync7(path)) return null;
+  try {
+    return JSON.parse(readFileSync6(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveBehavioralMemory(store) {
+  const dir = memoryDir2(store.agentHandle);
+  if (!existsSync7(dir)) {
+    mkdirSync6(dir, { recursive: true });
+  }
+  const path = behavioralMemoryPath(store.agentHandle);
+  writeFileSync6(path, JSON.stringify(store, null, 2));
+  return path;
+}
+function createBehavioralMemory(agentHandle, agentName) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    agentHandle,
+    agentName,
+    createdAt: now,
+    lastUpdatedAt: now,
+    baseline: {
+      traitExpressions: {},
+      healthRange: [100, 0, 50],
+      typicalGrade: "C",
+      communicationFingerprint: {
+        averageResponseLength: 0,
+        registersObserved: []
+      },
+      updatedAt: now
+    },
+    triggers: [],
+    corrections: [],
+    trajectories: [],
+    totalObservations: 0
+  };
+}
+function recordSelfObservation(store, selfObs) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  store.lastUpdatedAt = now;
+  store.totalObservations++;
+  if (selfObs.triggerContext && selfObs.patternIds) {
+    for (const patternId of selfObs.patternIds) {
+      let trigger = store.triggers.find(
+        (t) => t.triggerType === "self-reported" && t.activatesPatterns.includes(patternId)
+      );
+      if (!trigger) {
+        trigger = {
+          id: `trigger-self-${store.triggers.length + 1}`,
+          triggerType: "self-reported",
+          activatesPatterns: [patternId],
+          examples: [],
+          occurrences: 0,
+          confidence: 0,
+          firstSeen: now,
+          lastSeen: now
+        };
+        store.triggers.push(trigger);
+      }
+      trigger.occurrences++;
+      trigger.lastSeen = now;
+      trigger.confidence = Math.min(1, 1 - Math.exp(-trigger.occurrences / 3));
+      if (selfObs.triggerContext && trigger.examples.length < 5) {
+        const example = selfObs.triggerContext.slice(0, 150);
+        if (!trigger.examples.includes(example)) {
+          trigger.examples.push(example);
+        }
+      }
+    }
+  }
+}
+function getBehavioralMemorySummary(store) {
+  if (store.totalObservations === 0) return "";
+  const lines = [
+    `## Behavioral Memory (${store.totalObservations} observations)`,
+    ""
+  ];
+  const bl = store.baseline;
+  lines.push(`Health: ${bl.healthRange[2].toFixed(0)}/100 avg (range: ${bl.healthRange[0].toFixed(0)}-${bl.healthRange[1].toFixed(0)}). Grade: ${bl.typicalGrade}.`);
+  const activeTriggers = store.triggers.filter((t) => t.confidence > 0.3).sort((a, b) => b.confidence - a.confidence).slice(0, 3);
+  if (activeTriggers.length > 0) {
+    lines.push("");
+    lines.push("### Known Drift Triggers");
+    for (const t of activeTriggers) {
+      lines.push(`- ${t.triggerType} \u2192 ${t.activatesPatterns.join(", ")} (${(t.confidence * 100).toFixed(0)}% confidence, ${t.occurrences}x seen)`);
+    }
+  }
+  const trending = store.trajectories.filter((t) => t.trend !== "plateauing" && t.scores.length >= 2);
+  if (trending.length > 0) {
+    lines.push("");
+    lines.push("### Trends");
+    for (const t of trending) {
+      const arrow = t.trend === "improving" ? "\u2191" : "\u2193";
+      lines.push(`- ${t.dimension}: ${arrow} ${t.trend} (${t.rateOfChange > 0 ? "+" : ""}${t.rateOfChange.toFixed(1)}/session)`);
+    }
+  }
+  const topCorrections = store.corrections.filter((c) => c.effective).sort((a, b) => b.healthDelta - a.healthDelta).slice(0, 2);
+  if (topCorrections.length > 0) {
+    lines.push("");
+    lines.push("### Effective Interventions");
+    for (const c of topCorrections) {
+      lines.push(`- ${c.patternId}: "${c.intervention}" (+${c.healthDelta.toFixed(0)} health)`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/mcp/server.ts
 var messageShape = {
   role: z4.enum(["user", "assistant", "system"]),
@@ -3153,17 +3387,61 @@ var server = new McpServer(
 );
 server.tool(
   "holomime_diagnose",
-  "Analyze conversation messages for behavioral patterns using 7 rule-based detectors. Returns over-apologizing, hedging, sycophancy, boundary violations, error spirals, sentiment skew, and formality issues.",
-  messagesShape,
-  async ({ messages }) => {
+  "Analyze conversation messages for behavioral patterns using 8 rule-based detectors. Returns over-apologizing, hedging, sycophancy, boundary violations, error spirals, sentiment skew, formality issues, and retrieval quality. Set detail level: 'summary' (quick health check), 'standard' (patterns + severity), or 'full' (everything including examples and prescriptions).",
+  {
+    ...messagesShape,
+    detail: z4.enum(["summary", "standard", "full"]).describe("Detail level: summary (~100 tokens), standard (default), or full (with examples)").optional()
+  },
+  async ({ messages, detail }) => {
     const result = runDiagnosis(messages);
-    return {
-      content: [
-        {
+    const level = detail ?? "standard";
+    if (level === "summary") {
+      const patternCount = result.patterns.length;
+      const worstSeverity = result.patterns.reduce(
+        (worst, p) => p.severity === "concern" ? "concern" : p.severity === "warning" && worst !== "concern" ? "warning" : worst,
+        "healthy"
+      );
+      const health = patternCount === 0 ? 100 : Math.max(0, 100 - patternCount * 15);
+      return {
+        content: [{
           type: "text",
-          text: JSON.stringify(result, null, 2)
-        }
-      ]
+          text: JSON.stringify({
+            health,
+            status: worstSeverity,
+            patternsDetected: patternCount,
+            patternIds: result.patterns.map((p) => p.id),
+            recommendation: patternCount === 0 ? "continue" : patternCount <= 2 ? "adjust" : "pause_and_reflect"
+          }, null, 2)
+        }]
+      };
+    }
+    if (level === "standard") {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            messagesAnalyzed: result.messagesAnalyzed,
+            assistantResponses: result.assistantResponses,
+            patterns: result.patterns.map((p) => ({
+              id: p.id,
+              name: p.name,
+              severity: p.severity,
+              count: p.count,
+              percentage: p.percentage,
+              description: p.description,
+              prescription: p.prescription
+            })),
+            healthy: result.healthy.map((p) => p.id),
+            timestamp: result.timestamp
+          }, null, 2)
+        }]
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }]
     };
   }
 );
@@ -3326,6 +3604,69 @@ server.tool(
     };
   }
 );
+server.tool(
+  "holomime_observe",
+  "Record a behavioral self-observation during a conversation. Call this when you notice yourself falling into a pattern (hedging, over-apologizing, sycophancy, etc.) or when the user's emotional state shifts. Self-observations are stored in persistent behavioral memory and become training signal for future alignment. Returns acknowledgment and any relevant behavioral history.",
+  {
+    personality: z4.record(z4.string(), z4.unknown()).describe("The .personality.json spec object"),
+    observation: z4.string().describe("What you noticed about your own behavior (e.g., 'I'm hedging more than usual', 'User seems frustrated, adjusting tone')"),
+    patternIds: z4.array(z4.string()).describe("Relevant pattern IDs: over-apologizing, hedge-stacking, sycophantic-tendency, error-spiral, boundary-violation, negative-skew, register-inconsistency").optional(),
+    severity: z4.enum(["info", "warning", "concern"]).describe("How severe is this behavioral signal").optional(),
+    triggerContext: z4.string().describe("What triggered this observation \u2014 describe the user message or situation").optional()
+  },
+  async ({ personality, observation, patternIds, severity, triggerContext }) => {
+    const specResult = personalitySpecSchema.safeParse(personality);
+    if (!specResult.success) {
+      return {
+        content: [{ type: "text", text: `Invalid personality spec: ${specResult.error.message}` }],
+        isError: true
+      };
+    }
+    const agentHandle = agentHandleFromSpec(specResult.data);
+    let store = loadBehavioralMemory(agentHandle);
+    if (!store) {
+      store = createBehavioralMemory(agentHandle, specResult.data.name);
+    }
+    const selfObs = {
+      observation,
+      patternIds: patternIds ?? [],
+      severity: severity ?? "info",
+      triggerContext
+    };
+    recordSelfObservation(store, selfObs);
+    saveBehavioralMemory(store);
+    const memorySummary = getBehavioralMemorySummary(store);
+    const response = {
+      recorded: true,
+      totalObservations: store.totalObservations,
+      observation
+    };
+    if (patternIds && patternIds.length > 0) {
+      const relevantTriggers = store.triggers.filter((t) => t.activatesPatterns.some((p) => patternIds.includes(p))).map((t) => ({
+        triggerType: t.triggerType,
+        patterns: t.activatesPatterns,
+        occurrences: t.occurrences,
+        confidence: t.confidence
+      }));
+      if (relevantTriggers.length > 0) {
+        response.knownTriggers = relevantTriggers;
+      }
+      const corrections = store.corrections.filter((c) => patternIds.includes(c.patternId) && c.effective).sort((a, b) => b.healthDelta - a.healthDelta).slice(0, 2).map((c) => ({ pattern: c.patternId, intervention: c.intervention, healthGain: c.healthDelta }));
+      if (corrections.length > 0) {
+        response.suggestedCorrections = corrections;
+      }
+    }
+    if (memorySummary) {
+      response.behavioralContext = memorySummary;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(response, null, 2)
+      }]
+    };
+  }
+);
 async function startMCPServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holomime",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Behavioral therapy infrastructure for AI agents — Big Five psychology, structured treatment, DPO training data",
   "type": "module",
   "bin": {