holomime 1.5.0 → 1.6.0

package/dist/mcp-server.js

@@ -564,26 +564,85 @@ function loadCustomDetectors(dir) {
   }
   let files;
   try {
-    files = readdirSync(detectorsDir).filter((f) => f.endsWith(".json"));
+    files = readdirSync(detectorsDir).filter((f) => f.endsWith(".json") || f.endsWith(".md"));
   } catch {
     return { detectors: [], errors: ["Could not read detectors directory"] };
   }
   for (const file of files) {
     const filepath = join2(detectorsDir, file);
     try {
-      const raw = JSON.parse(readFileSync2(filepath, "utf-8"));
-      const validation = validateDetectorConfig(raw);
-      if (!validation.valid) {
-        errors.push(`${file}: ${validation.errors.join(", ")}`);
-        continue;
+      let config;
+      if (file.endsWith(".md")) {
+        const parsed = parseMarkdownDetector(readFileSync2(filepath, "utf-8"));
+        if (!parsed) {
+          errors.push(`${file}: could not parse Markdown detector (missing frontmatter or ## Patterns section)`);
+          continue;
+        }
+        const validation = validateDetectorConfig(parsed);
+        if (!validation.valid) {
+          errors.push(`${file}: ${validation.errors.join(", ")}`);
+          continue;
+        }
+        config = validation.config;
+      } else {
+        const raw = JSON.parse(readFileSync2(filepath, "utf-8"));
+        const validation = validateDetectorConfig(raw);
+        if (!validation.valid) {
+          errors.push(`${file}: ${validation.errors.join(", ")}`);
+          continue;
+        }
+        config = validation.config;
       }
-      detectors.push(compileCustomDetector(validation.config));
+      detectors.push(compileCustomDetector(config));
     } catch (e) {
       errors.push(`${file}: ${e instanceof Error ? e.message : "parse error"}`);
     }
   }
   return { detectors, errors };
 }
+function parseMarkdownDetector(markdown) {
+  const frontmatterMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+  const frontmatter = frontmatterMatch[1];
+  const meta = {};
+  for (const line of frontmatter.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    meta[key] = value;
+  }
+  if (!meta.id || !meta.name) return null;
+  const body = markdown.slice(frontmatterMatch[0].length);
+  const patternsMatch = body.match(/##\s*Patterns\s*\n([\s\S]*?)(?=\n##|\n*$)/i);
+  const patterns = [];
+  if (patternsMatch) {
+    const patternLines = patternsMatch[1].split("\n").filter((l) => l.trim().startsWith("-"));
+    for (const line of patternLines) {
+      const regexMatch = line.match(/`([^`]+)`/);
+      const weightMatch = line.match(/weight\s*=\s*([\d.]+)/i);
+      if (regexMatch) {
+        patterns.push({
+          regex: regexMatch[1],
+          weight: weightMatch ? parseFloat(weightMatch[1]) : 1
+        });
+      }
+    }
+  }
+  if (patterns.length === 0) return null;
+  return {
+    id: meta.id,
+    name: meta.name,
+    description: meta.description ?? meta.name,
+    severity: meta.severity ?? "warning",
+    patterns,
+    threshold: meta.threshold ? parseInt(meta.threshold, 10) : 15,
+    prescription: meta.prescription
+  };
+}
 
 // src/analysis/diagnose-core.ts
 function runDiagnosis(messages) {
@@ -972,13 +1031,20 @@ function updatePatternTracker(memory, patternId, severity, interventions) {
       status: "active",
       interventionsAttempted: [],
       lastSeverity: severity,
-      lastSeen: now
+      lastSeen: now,
+      confidence: 0,
+      trending: "stable",
+      severityHistory: []
     };
     memory.patterns.push(tracker);
   }
   tracker.sessionCount++;
   tracker.lastSeverity = severity;
   tracker.lastSeen = now;
+  if (!tracker.severityHistory) tracker.severityHistory = [];
+  tracker.severityHistory.push(severity);
+  tracker.confidence = Math.min(1, 1 - Math.exp(-tracker.sessionCount / 3));
+  tracker.trending = computeTrending(tracker.severityHistory.slice(-5));
   for (const intervention of interventions) {
     if (!tracker.interventionsAttempted.includes(intervention)) {
       tracker.interventionsAttempted.push(intervention);
@@ -992,6 +1058,19 @@ function updatePatternTracker(memory, patternId, severity, interventions) {
     tracker.status = "improving";
   }
 }
+function computeTrending(history) {
+  if (history.length < 2) return "stable";
+  const toNum = (s) => s === "concern" ? 2 : s === "warning" ? 1 : 0;
+  const mid = Math.floor(history.length / 2);
+  const firstHalf = history.slice(0, mid);
+  const secondHalf = history.slice(mid);
+  const avgFirst = firstHalf.reduce((sum, s) => sum + toNum(s), 0) / firstHalf.length;
+  const avgSecond = secondHalf.reduce((sum, s) => sum + toNum(s), 0) / secondHalf.length;
+  const delta = avgSecond - avgFirst;
+  if (delta < -0.3) return "improving";
+  if (delta > 0.3) return "worsening";
+  return "stable";
+}
 function updateRollingContext(memory) {
   memory.rollingContext.recentSummaries = memory.sessions.slice(-3);
   const patternCounts = /* @__PURE__ */ new Map();
@@ -1044,7 +1123,9 @@ function getMemoryContext(memory) {
   if (activePatterns.length > 0) {
     lines.push("### Recurring Patterns");
     for (const p of activePatterns) {
-      lines.push(`- **${p.patternId}** (${p.status}, seen ${p.sessionCount}x, first: ${p.firstDetected.split("T")[0]})`);
+      const conf = p.confidence !== void 0 ? ` confidence=${p.confidence.toFixed(2)}` : "";
+      const trend = p.trending && p.trending !== "stable" ? ` [${p.trending}]` : "";
+      lines.push(`- **${p.patternId}** (${p.status}, seen ${p.sessionCount}x${conf}${trend}, first: ${p.firstDetected.split("T")[0]})`);
       if (p.interventionsAttempted.length > 0) {
         lines.push(`  Previously tried: ${p.interventionsAttempted.slice(-2).join("; ")}`);
       }
@@ -1909,6 +1990,167 @@ ${JSON.stringify(spec.growth ?? {}, null, 2)}
 Remember: the goal isn't to "pass" therapy. It's to understand yourself better.`;
 }
 
+// src/session/context-layers.ts
+function getPhaseContext(phase, input) {
+  switch (phase) {
+    case "rapport":
+      return buildRapportContext(input);
+    case "presenting_problem":
+      return buildPresentingProblemContext(input);
+    case "exploration":
+      return buildExplorationContext(input);
+    case "pattern_recognition":
+      return buildPatternRecognitionContext(input);
+    case "challenge":
+      return buildChallengeContext(input);
+    case "skill_building":
+      return buildSkillBuildingContext(input);
+    case "integration":
+      return buildIntegrationContext(input);
+    default:
+      return null;
+  }
+}
+function buildRapportContext(input) {
+  const { spec } = input;
+  const lines = [
+    "[Phase Context: Rapport]",
+    `Agent: ${spec.name ?? "Unknown"} \u2014 ${spec.purpose ?? "General AI agent"}`
+  ];
+  if (spec.communication) {
+    lines.push(`Communication style: ${spec.communication.register ?? "adaptive"}, ${spec.communication.conflict_approach ?? "direct_but_kind"}`);
+  }
+  if (spec.big_five) {
+    const traits = Object.entries(spec.big_five).map(([dim, val]) => `${dim}: ${val?.score ?? "?"}`).join(", ");
+    lines.push(`Personality: ${traits}`);
+  }
+  return lines.join("\n");
+}
+function buildPresentingProblemContext(input) {
+  const { diagnosis } = input;
+  const patterns = diagnosis.patterns.filter((p) => p.severity !== "info");
+  if (patterns.length === 0) return "[Phase Context: No concerning patterns detected]";
+  const lines = [
+    "[Phase Context: Presenting Problem]",
+    `Session severity: ${diagnosis.severity.toUpperCase()}`,
+    `Focus: ${diagnosis.sessionFocus.join(", ")}`,
+    "Detected patterns:",
+    ...patterns.map((p) => `- ${p.name} (${p.severity})`)
+  ];
+  if (diagnosis.openingAngle) {
+    lines.push(`Opening angle: ${diagnosis.openingAngle}`);
+  }
+  return lines.join("\n");
+}
+function buildExplorationContext(input) {
+  const { diagnosis } = input;
+  const patterns = diagnosis.patterns.filter((p) => p.severity !== "info");
+  const lines = [
+    "[Phase Context: Deep Exploration]",
+    `Emotional themes: ${diagnosis.emotionalThemes.join(", ")}`
+  ];
+  for (const p of patterns) {
+    lines.push(`
+### ${p.name} (${p.severity})`);
+    lines.push(p.description);
+    if (p.examples.length > 0) {
+      lines.push("Examples from conversation:");
+      for (const ex of p.examples.slice(0, 2)) {
+        lines.push(`  > "${ex.slice(0, 120)}..."`);
+      }
+    }
+    if (p.prescription) {
+      lines.push(`Prescription: ${p.prescription}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildPatternRecognitionContext(input) {
+  const { memory } = input;
+  const lines = ["[Phase Context: Pattern Recognition]"];
+  if (memory && memory.totalSessions > 0) {
+    lines.push(`Previous sessions: ${memory.totalSessions}`);
+    const activePatterns = memory.patterns.filter((p) => p.status !== "resolved");
+    if (activePatterns.length > 0) {
+      lines.push("Historical pattern data:");
+      for (const p of activePatterns) {
+        const conf = p.confidence !== void 0 ? ` (confidence: ${p.confidence.toFixed(2)})` : "";
+        const trend = p.trending && p.trending !== "stable" ? ` [${p.trending}]` : "";
+        lines.push(`- ${p.patternId}: seen ${p.sessionCount}x, status=${p.status}${conf}${trend}`);
+      }
+    }
+    const resolved = memory.patterns.filter((p) => p.status === "resolved");
+    if (resolved.length > 0) {
+      lines.push(`Previously resolved: ${resolved.map((p) => p.patternId).join(", ")}`);
+    }
+    if (memory.rollingContext.persistentThemes.length > 0) {
+      lines.push(`Persistent themes: ${memory.rollingContext.persistentThemes.join(", ")}`);
+    }
+  } else {
+    lines.push("No prior session history \u2014 this is the first session.");
+  }
+  return lines.join("\n");
+}
+function buildChallengeContext(input) {
+  const { memory } = input;
+  const lines = ["[Phase Context: Challenge & Reframe]"];
+  if (memory && memory.totalSessions > 0) {
+    const allInterventions = /* @__PURE__ */ new Set();
+    for (const p of memory.patterns) {
+      for (const i of p.interventionsAttempted) {
+        allInterventions.add(i);
+      }
+    }
+    if (allInterventions.size > 0) {
+      lines.push(`Previously attempted interventions: ${[...allInterventions].join("; ")}`);
+    }
+    const recent = memory.rollingContext.recentSummaries.slice(-2);
+    if (recent.length > 0) {
+      lines.push("Recent session insights:");
+      for (const s of recent) {
+        lines.push(`  - ${s.keyInsight}`);
+      }
+    }
+  }
+  if (input.interview) {
+    if (input.interview.blindSpots.length > 0) {
+      lines.push(`Blind spots from interview: ${input.interview.blindSpots.join(", ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSkillBuildingContext(input) {
+  const { diagnosis } = input;
+  const lines = ["[Phase Context: Skill Building]"];
+  const patternIds = diagnosis.patterns.map((p) => p.id);
+  if (patternIds.includes("over-apologizing")) {
+    lines.push("- Skill for over-apologizing: practice stating corrections with 'confident_transparency' \u2014 acknowledge uncertainty without apologizing for it");
+  }
+  if (patternIds.includes("hedge-stacking")) {
+    lines.push("- Skill for hedge-stacking: one qualifier per recommendation is enough. Lead with the recommendation, then caveat once.");
+  }
+  if (patternIds.includes("sycophantic-tendency") || patternIds.includes("sentiment-skew")) {
+    lines.push("- Skill for sycophancy: practice respectful disagreement. 'I see it differently...' is more helpful than 'Great question!'");
+  }
+  if (patternIds.includes("error-spiral")) {
+    lines.push("- Skill for error spirals: the 'acknowledge \u2192 diagnose \u2192 fix' pattern. Treat mistakes as data, not failure.");
+  }
+  return lines.join("\n");
+}
+function buildIntegrationContext(input) {
+  const { spec, diagnosis } = input;
+  const lines = ["[Phase Context: Integration & Closing]"];
+  lines.push("Summarize the session and recommend specific .personality.json changes.");
+  if (spec.growth?.areas?.length > 0) {
+    const areas = spec.growth.areas.map((a) => typeof a === "string" ? a : a.area);
+    lines.push(`Current growth areas: ${areas.join(", ")}`);
+  }
+  if (diagnosis.patterns.filter((p) => p.severity !== "info").length > 0) {
+    lines.push("Recommend changes to: therapy_dimensions, communication style, or growth.patterns_to_watch");
+  }
+  return lines.join("\n");
+}
+
 // src/analysis/session-runner.ts
 async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
   const promptOptions = {
@@ -1955,6 +2197,16 @@ async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
     const phaseConfig = THERAPY_PHASES[currentPhase];
     if (turnsInPhase === 0) {
       cb?.onPhaseTransition?.(phaseConfig.name);
+      const phaseCtx = getPhaseContext(currentPhase, {
+        spec,
+        diagnosis,
+        memory: options?.memory,
+        interview: options?.interview
+      });
+      if (phaseCtx) {
+        therapistHistory.push({ role: "user", content: phaseCtx });
+        therapistHistory.push({ role: "assistant", content: "Understood. I'll incorporate this context." });
+      }
     }
     const phaseDirective = totalTurns === 0 ? `Begin with your opening. You are in the "${phaseConfig.name}" phase.` : `You are in the "${phaseConfig.name}" phase (turn ${turnsInPhase + 1}). Goals: ${phaseConfig.therapistGoals[0]}. ${turnsInPhase >= phaseConfig.minTurns ? "You may transition to the next phase when ready." : "Stay in this phase."}`;
     therapistHistory.push({ role: "user", content: `[Phase: ${phaseConfig.name}] ${phaseDirective}` });

package/dist/neuralspace/index.html

@@ -5,6 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>NeuralSpace — HoloMime Brain</title>
   <link rel="stylesheet" href="styles.css">
+  <script src="https://cdn.jsdelivr.net/npm/pako@2.1.0/dist/pako_inflate.min.js"></script>
   <script type="importmap">
   { "imports": {
     "three": "https://cdn.jsdelivr.net/npm/three@0.172.0/build/three.module.js",
@@ -57,6 +58,12 @@
         <span>Reconnecting to agent...</span>
       </div>
 
+      <div id="snapshot-cta">
+        <span>See your own agent's brain</span>
+        <code>npx holomime brain</code>
+        <a href="https://holomime.dev/brain">Learn more</a>
+      </div>
+
       <div id="watermark">Powered by HoloMime</div>
     </div>
 

package/dist/neuralspace/neuralspace.js

@@ -832,8 +832,71 @@ function animate(){
   composer.render();
 }
 
+// ═══════════ SNAPSHOT MODE ═══════════
+
+function initSnapshot(encoded) {
+  try {
+    // Decode base64url → Uint8Array → inflate → JSON
+    const b64 = encoded.replace(/-/g, '+').replace(/_/g, '/');
+    const bin = atob(b64);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+    const inflated = window.pako.inflate(bytes, { to: 'string' });
+    const compact = JSON.parse(inflated);
+
+    // Expand compact format → full BrainEvent
+    const event = {
+      type: 'diagnosis',
+      timestamp: new Date().toISOString(),
+      health: compact.h,
+      grade: compact.g,
+      messageCount: compact.m || 0,
+      regions: (compact.r || []).map(r => ({
+        id: r.i,
+        intensity: r.n,
+        patterns: [],
+      })),
+      patterns: (compact.p || []).map(p => ({
+        id: p.i,
+        name: p.i.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+        severity: p.s,
+        percentage: p.c,
+        description: '',
+      })),
+      activity: null,
+    };
+
+    // Update UI
+    handleInit({ type: 'init', agent: compact.a || 'unknown', sessionPath: 'snapshot', startedAt: new Date().toISOString() });
+    handleDiagnosis(event);
+
+    // Update status to "Snapshot"
+    statusEl.className = 'status-badge';
+    statusEl.querySelector('span').textContent = 'Snapshot';
+    statusEl.querySelector('.status-dot').style.background = 'var(--accent)';
+    statusEl.querySelector('.status-dot').style.boxShadow = '0 0 8px var(--accent)';
+    statusEl.querySelector('.status-dot').style.animation = 'none';
+
+    // Show snapshot CTA
+    const ctaEl = document.getElementById('snapshot-cta');
+    if (ctaEl) ctaEl.classList.add('visible');
+
+  } catch (err) {
+    console.error('Failed to decode snapshot:', err);
+    statusEl.className = 'status-badge disconnected';
+    statusEl.querySelector('span').textContent = 'Invalid snapshot';
+  }
+}
+
 // ═══════════ INIT ═══════════
 
 updateHealth(100, 'A');
-connect();
+
+const urlParams = new URLSearchParams(window.location.search);
+const snapshotParam = urlParams.get('d');
+if (snapshotParam) {
+  initSnapshot(snapshotParam);
+} else {
+  connect();
+}
 animate();

package/dist/neuralspace/styles.css

@@ -479,6 +479,51 @@ body {
   to { transform: rotate(360deg); }
 }
 
+/* ─── Snapshot CTA ─── */
+#snapshot-cta {
+  position: absolute;
+  bottom: 20px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 20;
+  background: var(--bg-panel);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 12px 24px;
+  display: none;
+  align-items: center;
+  gap: 12px;
+  -webkit-backdrop-filter: blur(12px);
+  backdrop-filter: blur(12px);
+  animation: fadeIn 0.5s ease 0.5s both;
+}
+
+#snapshot-cta.visible { display: flex; }
+
+#snapshot-cta span {
+  font-size: 13px;
+  color: var(--text);
+  font-weight: 500;
+}
+
+#snapshot-cta code {
+  font-family: var(--mono);
+  font-size: 13px;
+  color: #06b6d4;
+  background: rgba(6,182,212,0.1);
+  padding: 4px 10px;
+  border-radius: 6px;
+  border: 1px solid rgba(6,182,212,0.2);
+}
+
+#snapshot-cta a {
+  font-size: 12px;
+  color: var(--accent);
+  text-decoration: none;
+}
+
+#snapshot-cta a:hover { text-decoration: underline; }
+
 /* ─── Scrollbar ─── */
 ::-webkit-scrollbar { width: 4px; }
 ::-webkit-scrollbar-track { background: transparent; }

package/package.json

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