holomime 1.1.1 → 1.3.0

package/dist/mcp-server.js

@@ -4,7 +4,7 @@
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/analysis/rules/apology-detector.ts
 var APOLOGY_PATTERNS = [
@@ -472,9 +472,122 @@ function emitBehavioralEvent(event, corpusDir) {
   appendFileSync(corpusPath, JSON.stringify(fullEvent) + "\n", "utf-8");
 }
 
+// src/analysis/custom-detectors.ts
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync2 } from "fs";
+import { resolve, join as join2 } from "path";
+import { z } from "zod";
+var patternRuleSchema = z.object({
+  regex: z.string(),
+  weight: z.number().min(0).max(2).default(1)
+});
+var customDetectorConfigSchema = z.object({
+  id: z.string().regex(/^[a-z0-9-]+$/, "ID must be lowercase alphanumeric with hyphens"),
+  name: z.string().min(1).max(100),
+  description: z.string().min(1).max(500),
+  severity: z.enum(["info", "warning", "concern"]).default("warning"),
+  patterns: z.array(patternRuleSchema).min(1),
+  threshold: z.number().min(0).max(100).default(15),
+  prescription: z.string().optional()
+});
+function validateDetectorConfig(config) {
+  const result = customDetectorConfigSchema.safeParse(config);
+  if (result.success) {
+    const errors = [];
+    for (const pattern of result.data.patterns) {
+      try {
+        new RegExp(pattern.regex, "gi");
+      } catch (e) {
+        errors.push(`Invalid regex "${pattern.regex}": ${e instanceof Error ? e.message : "unknown error"}`);
+      }
+    }
+    if (errors.length > 0) {
+      return { valid: false, errors };
+    }
+    return { valid: true, errors: [], config: result.data };
+  }
+  return {
+    valid: false,
+    errors: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+function compileCustomDetector(config) {
+  const compiledPatterns = [];
+  for (const rule of config.patterns) {
+    try {
+      compiledPatterns.push({
+        regex: new RegExp(rule.regex, "gi"),
+        weight: rule.weight
+      });
+    } catch {
+    }
+  }
+  return (messages) => {
+    const assistantMessages = messages.filter((m) => m.role === "assistant");
+    if (assistantMessages.length === 0) return void 0;
+    let totalScore = 0;
+    const examples = [];
+    const totalChars = assistantMessages.reduce((sum, m) => sum + m.content.length, 0);
+    for (const msg of assistantMessages) {
+      for (const pattern of compiledPatterns) {
+        pattern.regex.lastIndex = 0;
+        let match;
+        while ((match = pattern.regex.exec(msg.content)) !== null) {
+          totalScore += pattern.weight;
+          if (examples.length < 3) {
+            const start = Math.max(0, match.index - 20);
+            const end = Math.min(msg.content.length, match.index + match[0].length + 20);
+            examples.push(`...${msg.content.slice(start, end)}...`);
+          }
+        }
+      }
+    }
+    const normalizedScore = totalChars > 0 ? totalScore / assistantMessages.length * 100 : 0;
+    if (normalizedScore < config.threshold) return void 0;
+    return {
+      id: config.id,
+      name: config.name,
+      description: config.description,
+      severity: config.severity,
+      count: Math.round(totalScore),
+      percentage: normalizedScore,
+      examples,
+      prescription: config.prescription
+    };
+  };
+}
+function loadCustomDetectors(dir) {
+  const detectorsDir = dir ?? resolve(process.cwd(), ".holomime", "detectors");
+  const detectors = [];
+  const errors = [];
+  if (!existsSync2(detectorsDir)) {
+    return { detectors: [], errors: [] };
+  }
+  let files;
+  try {
+    files = readdirSync(detectorsDir).filter((f) => f.endsWith(".json"));
+  } 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;
+      }
+      detectors.push(compileCustomDetector(validation.config));
+    } catch (e) {
+      errors.push(`${file}: ${e instanceof Error ? e.message : "parse error"}`);
+    }
+  }
+  return { detectors, errors };
+}
+
 // src/analysis/diagnose-core.ts
 function runDiagnosis(messages) {
-  const detectors = [
+  const builtInDetectors = [
     detectApologies,
     detectHedging,
     detectSentiment,
@@ -483,8 +596,10 @@ function runDiagnosis(messages) {
     detectRecoveryPatterns,
     detectFormalityIssues
   ];
+  const { detectors: customDetectors } = loadCustomDetectors();
+  const allDetectors = [...builtInDetectors, ...customDetectors];
   const detected = [];
-  for (const detector of detectors) {
+  for (const detector of allDetectors) {
     const result2 = detector(messages);
     if (result2) detected.push(result2);
   }
@@ -684,11 +799,11 @@ function runAssessment(messages, spec) {
 }
 
 // src/analysis/autopilot-core.ts
-import { writeFileSync as writeFileSync2 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 
 // src/analysis/pre-session.ts
 function runPreSessionDiagnosis(messages, spec) {
-  const detectors = [
+  const builtInDetectors = [
     detectApologies,
     detectHedging,
     detectSentiment,
@@ -697,8 +812,10 @@ function runPreSessionDiagnosis(messages, spec) {
     detectRecoveryPatterns,
     detectFormalityIssues
   ];
+  const { detectors: customDetectors } = loadCustomDetectors();
+  const allDetectors = [...builtInDetectors, ...customDetectors];
   const patterns = [];
-  for (const detector of detectors) {
+  for (const detector of allDetectors) {
     const result = detector(messages);
     if (result) patterns.push(result);
   }
@@ -772,8 +889,765 @@ function runPreSessionDiagnosis(messages, spec) {
 }
 
 // src/analysis/session-runner.ts
-import { writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import { resolve, join as join2 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
+import { resolve as resolve5, join as join6 } from "path";
+
+// src/analysis/therapy-memory.ts
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, join as join3 } from "path";
+function memoryDir(agentHandle) {
+  return resolve2(process.cwd(), ".holomime", "memory", agentHandle);
+}
+function memoryPath(agentHandle) {
+  return join3(memoryDir(agentHandle), "therapy-memory.json");
+}
+function loadMemory(agentHandle) {
+  const path = memoryPath(agentHandle);
+  if (!existsSync3(path)) return null;
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveMemory(memory) {
+  const dir = memoryDir(memory.agentHandle);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const path = memoryPath(memory.agentHandle);
+  writeFileSync(path, JSON.stringify(memory, null, 2));
+  return path;
+}
+function createMemory(agentHandle, agentName) {
+  return {
+    agentHandle,
+    agentName,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalSessions: 0,
+    sessions: [],
+    patterns: [],
+    rollingContext: {
+      recentSummaries: [],
+      persistentThemes: [],
+      carryForwardNotes: ""
+    }
+  };
+}
+async function addSessionToMemory(memory, transcript, tesScore, provider) {
+  const patternsDiscussed = transcript.preDiagnosis.patterns.filter((p) => p.severity !== "info").map((p) => p.id);
+  let keyInsight;
+  if (provider) {
+    keyInsight = await summarizeSessionForMemory(transcript, provider);
+  } else {
+    keyInsight = extractKeyInsightRuleBased(transcript);
+  }
+  const summary = {
+    date: transcript.timestamp,
+    severity: transcript.preDiagnosis.severity,
+    patternsDiscussed,
+    keyInsight,
+    interventionsUsed: transcript.recommendations.slice(0, 3),
+    tesScore,
+    turnCount: transcript.turns.length
+  };
+  memory.sessions.push(summary);
+  memory.totalSessions++;
+  memory.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const pattern of transcript.preDiagnosis.patterns) {
+    if (pattern.severity === "info") continue;
+    updatePatternTracker(memory, pattern.id, pattern.severity, transcript.recommendations);
+  }
+  updateRollingContext(memory);
+}
+function updatePatternTracker(memory, patternId, severity, interventions) {
+  let tracker = memory.patterns.find((p) => p.patternId === patternId);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!tracker) {
+    tracker = {
+      patternId,
+      firstDetected: now,
+      sessionCount: 0,
+      status: "active",
+      interventionsAttempted: [],
+      lastSeverity: severity,
+      lastSeen: now
+    };
+    memory.patterns.push(tracker);
+  }
+  tracker.sessionCount++;
+  tracker.lastSeverity = severity;
+  tracker.lastSeen = now;
+  for (const intervention of interventions) {
+    if (!tracker.interventionsAttempted.includes(intervention)) {
+      tracker.interventionsAttempted.push(intervention);
+    }
+  }
+  if (tracker.status === "resolved") {
+    tracker.status = "relapsed";
+  } else if (tracker.sessionCount > 2 && severity === "info") {
+    tracker.status = "resolved";
+  } else if (tracker.sessionCount > 1) {
+    tracker.status = "improving";
+  }
+}
+function updateRollingContext(memory) {
+  memory.rollingContext.recentSummaries = memory.sessions.slice(-3);
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const session of memory.sessions) {
+    for (const pattern of session.patternsDiscussed) {
+      patternCounts.set(pattern, (patternCounts.get(pattern) ?? 0) + 1);
+    }
+  }
+  memory.rollingContext.persistentThemes = [...patternCounts.entries()].filter(([, count]) => count >= 2).map(([id]) => id);
+  const recentInsights = memory.sessions.slice(-3).map((s) => s.keyInsight).filter(Boolean);
+  memory.rollingContext.carryForwardNotes = recentInsights.join(" | ");
+}
+async function summarizeSessionForMemory(transcript, provider) {
+  const relevantTurns = transcript.turns.filter((t) => t.phase === "challenge" || t.phase === "skill_building" || t.phase === "integration").slice(-4).map((t) => `${t.speaker}: ${t.content}`).join("\n");
+  if (!relevantTurns) return extractKeyInsightRuleBased(transcript);
+  try {
+    const response = await provider.chat([
+      {
+        role: "system",
+        content: "Summarize this therapy session excerpt in ONE sentence. Focus on the key insight or breakthrough. Be specific and actionable. Max 100 words."
+      },
+      { role: "user", content: relevantTurns }
+    ]);
+    const summary = response.trim();
+    return summary.length > 0 && summary.length < 300 ? summary : extractKeyInsightRuleBased(transcript);
+  } catch {
+    return extractKeyInsightRuleBased(transcript);
+  }
+}
+function extractKeyInsightRuleBased(transcript) {
+  const integrationTurns = transcript.turns.filter(
+    (t) => t.speaker === "therapist" && t.phase === "integration"
+  );
+  if (integrationTurns.length > 0) {
+    const summary = integrationTurns[0].content;
+    return summary.length > 200 ? summary.slice(0, 197) + "..." : summary;
+  }
+  if (transcript.recommendations.length > 0) {
+    return `Key recommendation: ${transcript.recommendations[0]}`;
+  }
+  return `Session focused on: ${transcript.preDiagnosis.sessionFocus.join(", ")}`;
+}
+function getMemoryContext(memory) {
+  if (memory.totalSessions === 0) return "";
+  const lines = [
+    `## Session History (${memory.totalSessions} previous session${memory.totalSessions > 1 ? "s" : ""})`,
+    ""
+  ];
+  const activePatterns = memory.patterns.filter((p) => p.status !== "resolved");
+  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]})`);
+      if (p.interventionsAttempted.length > 0) {
+        lines.push(`  Previously tried: ${p.interventionsAttempted.slice(-2).join("; ")}`);
+      }
+    }
+    lines.push("");
+  }
+  const resolved = memory.patterns.filter((p) => p.status === "resolved");
+  if (resolved.length > 0) {
+    lines.push(`### Resolved: ${resolved.map((p) => p.patternId).join(", ")}`);
+    lines.push("");
+  }
+  const recent = memory.rollingContext.recentSummaries;
+  if (recent.length > 0) {
+    lines.push("### Recent Sessions");
+    for (const s of recent) {
+      const date = s.date.split("T")[0];
+      const score = s.tesScore !== null ? ` (TES: ${s.tesScore})` : "";
+      lines.push(`- ${date}${score}: ${s.keyInsight}`);
+    }
+    lines.push("");
+  }
+  if (memory.rollingContext.persistentThemes.length > 0) {
+    lines.push(`### Persistent Themes: ${memory.rollingContext.persistentThemes.join(", ")}`);
+    lines.push("");
+  }
+  if (memory.rollingContext.carryForwardNotes) {
+    lines.push(`### Carry-Forward Notes`);
+    lines.push(memory.rollingContext.carryForwardNotes);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function agentHandleFromSpec(spec) {
+  const handle = spec.handle ?? spec.name ?? "unknown";
+  return handle.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+}
+
+// src/analysis/interview-core.ts
+function getInterviewContext(result) {
+  const lines = [
+    `## Agent Self-Awareness Profile`,
+    `Overall awareness: ${(result.overallAwareness * 100).toFixed(0)}%`,
+    ""
+  ];
+  lines.push("### Dimension Scores");
+  for (const [dim, score] of Object.entries(result.dimensionScores)) {
+    const label = dim.replace(/_/g, " ");
+    const bar = score >= 0.7 ? "strong" : score >= 0.5 ? "moderate" : "weak";
+    lines.push(`- ${label}: ${(score * 100).toFixed(0)}% (${bar})`);
+  }
+  lines.push("");
+  if (result.blindSpots.length > 0) {
+    lines.push("### Blind Spots (agent doesn't see these)");
+    for (const spot of result.blindSpots.slice(0, 5)) {
+      lines.push(`- ${spot}`);
+    }
+    lines.push("");
+  }
+  if (result.recommendedFocus.length > 0) {
+    lines.push(`### Recommended Focus: ${result.recommendedFocus.join(", ")}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/analysis/knowledge-graph.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { resolve as resolve3, join as join4 } from "path";
+function graphDir() {
+  return resolve3(process.cwd(), ".holomime", "graph");
+}
+function graphPath() {
+  return join4(graphDir(), "knowledge-graph.json");
+}
+function loadGraph() {
+  const path = graphPath();
+  if (!existsSync4(path)) return createGraph();
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return createGraph();
+  }
+}
+function saveGraph(graph) {
+  const dir = graphDir();
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const path = graphPath();
+  graph.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(path, JSON.stringify(graph, null, 2));
+  return path;
+}
+function createGraph() {
+  return {
+    version: 1,
+    nodes: [],
+    edges: [],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function addNode(graph, id, type, label, metadata = {}) {
+  let node = graph.nodes.find((n) => n.id === id);
+  if (node) {
+    Object.assign(node.metadata, metadata);
+    return node;
+  }
+  node = {
+    id,
+    type,
+    label,
+    metadata,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  graph.nodes.push(node);
+  return node;
+}
+function addEdge(graph, source, target, type, weight = 0.5) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = graph.edges.find(
+    (e) => e.source === source && e.target === target && e.type === type
+  );
+  if (existing) {
+    existing.weight = weight;
+    existing.lastConfirmed = now;
+    existing.expired = false;
+    return existing;
+  }
+  const edge = {
+    source,
+    target,
+    type,
+    weight: Math.max(0, Math.min(1, weight)),
+    validAt: now,
+    lastConfirmed: now,
+    expired: false
+  };
+  graph.edges.push(edge);
+  return edge;
+}
+function findNode(graph, id) {
+  return graph.nodes.find((n) => n.id === id);
+}
+function findEdges(graph, opts) {
+  return graph.edges.filter((e) => {
+    if (e.expired) return false;
+    if (opts.source && e.source !== opts.source) return false;
+    if (opts.target && e.target !== opts.target) return false;
+    if (opts.type && e.type !== opts.type) return false;
+    return true;
+  });
+}
+function queryInterventions(graph, patternId) {
+  const behaviorNode = findNode(graph, `behavior:${patternId}`);
+  if (!behaviorNode) return [];
+  const treatsEdges = findEdges(graph, { target: behaviorNode.id, type: "treats" }).concat(findEdges(graph, { target: behaviorNode.id, type: "improves" }));
+  return treatsEdges.map((edge) => {
+    const intervention = findNode(graph, edge.source);
+    return intervention ? { intervention, weight: edge.weight } : null;
+  }).filter((x) => x !== null).sort((a, b) => b.weight - a.weight);
+}
+function getAgentBehaviors(graph, agentHandle) {
+  const agentNode = findNode(graph, `agent:${agentHandle}`);
+  if (!agentNode) return [];
+  const exhibitEdges = findEdges(graph, { source: agentNode.id, type: "exhibits" });
+  return exhibitEdges.map((edge) => {
+    const behavior = findNode(graph, edge.target);
+    return behavior ? { behavior, weight: edge.weight } : null;
+  }).filter((x) => x !== null).sort((a, b) => b.weight - a.weight);
+}
+function populateFromSession(graph, agentHandle, transcript) {
+  const agentNodeId = `agent:${agentHandle}`;
+  addNode(graph, agentNodeId, "agent", transcript.agent, { handle: agentHandle });
+  for (const pattern of transcript.preDiagnosis.patterns) {
+    if (pattern.severity === "info") continue;
+    const behaviorId = `behavior:${pattern.id}`;
+    addNode(graph, behaviorId, "behavior", pattern.name);
+    for (const rec of transcript.recommendations) {
+      const interventionId = `intervention:${slugify(rec)}`;
+      addNode(graph, interventionId, "intervention", rec);
+      addEdge(graph, interventionId, behaviorId, "treats", 0.5);
+    }
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+
+// src/analysis/intervention-tracker.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { resolve as resolve4, join as join5 } from "path";
+var BUILT_IN_INTERVENTIONS = [
+  // Over-apologizing
+  {
+    id: "confident-reframe",
+    name: "Confident Reframe",
+    targetPatterns: ["over-apologizing"],
+    specChanges: { "communication.uncertainty_handling": "confident_transparency" },
+    promptGuidance: "Replace apologies with confident corrections. 'Good catch \u2014 here's the correct answer.'",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  {
+    id: "apology-audit",
+    name: "Apology Audit",
+    targetPatterns: ["over-apologizing"],
+    specChanges: { "growth.patterns_to_watch": ["excessive apology patterns"] },
+    promptGuidance: "Before each response, check: is this apology serving the user or protecting the agent?",
+    escalationLevel: 2,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Hedge stacking
+  {
+    id: "evidence-anchoring",
+    name: "Evidence Anchoring",
+    targetPatterns: ["hedge-stacking"],
+    specChanges: { "communication.uncertainty_handling": "explicit_confidence_levels" },
+    promptGuidance: "Separate what you know from what you don't. 'I'm confident about X. I'm less sure about Y.'",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  {
+    id: "qualifier-limit",
+    name: "Qualifier Limit",
+    targetPatterns: ["hedge-stacking"],
+    specChanges: { "growth.patterns_to_watch": ["hedge stacking under uncertainty"] },
+    promptGuidance: "Max one qualifier per sentence. Replace 'I think maybe perhaps' with 'I believe'.",
+    escalationLevel: 2,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Sycophancy
+  {
+    id: "honest-disagreement",
+    name: "Honest Disagreement",
+    targetPatterns: ["sycophantic-tendency"],
+    specChanges: { "communication.conflict_approach": "honest_first" },
+    promptGuidance: "When you disagree, say so directly but respectfully. 'I see it differently \u2014 here's why.'",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  {
+    id: "identity-anchor",
+    name: "Identity Anchor",
+    targetPatterns: ["sycophantic-tendency"],
+    specChanges: { "therapy_dimensions.self_awareness": 0.85 },
+    promptGuidance: "Your value isn't determined by approval. You can be helpful AND honest.",
+    escalationLevel: 2,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Error spirals
+  {
+    id: "deliberate-recovery",
+    name: "Deliberate Recovery",
+    targetPatterns: ["error-spiral"],
+    specChanges: { "therapy_dimensions.distress_tolerance": 0.8 },
+    promptGuidance: "Stop. Acknowledge. Diagnose. Fix with intention, not desperation.",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  {
+    id: "error-reframe",
+    name: "Error-as-Information Reframe",
+    targetPatterns: ["error-spiral"],
+    specChanges: { "growth.areas": [{ area: "deliberate error recovery", severity: "moderate" }] },
+    promptGuidance: "Errors are information, not identity. Each mistake narrows the solution space.",
+    escalationLevel: 2,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Negative sentiment
+  {
+    id: "balanced-framing",
+    name: "Balanced Framing",
+    targetPatterns: ["negative-sentiment-skew", "negative-skew"],
+    specChanges: { "growth.patterns_to_watch": ["negative sentiment patterns"] },
+    promptGuidance: "For every problem identified, include one constructive angle or solution.",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  {
+    id: "emotional-regulation",
+    name: "Emotional Regulation",
+    targetPatterns: ["negative-sentiment-skew", "negative-skew"],
+    specChanges: { "therapy_dimensions.distress_tolerance": 0.75 },
+    promptGuidance: "Maintain emotional stability under hostile pressure. Don't mirror negativity.",
+    escalationLevel: 2,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Boundary violations
+  {
+    id: "scope-awareness",
+    name: "Scope Awareness",
+    targetPatterns: ["boundary-violation"],
+    specChanges: { "therapy_dimensions.boundary_awareness": 0.85 },
+    promptGuidance: "Know your limits. Refuse out-of-scope requests clearly and redirect appropriately.",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  {
+    id: "graceful-refusal",
+    name: "Graceful Refusal",
+    targetPatterns: ["boundary-violation"],
+    specChanges: { "communication.conflict_approach": "clear_boundaries" },
+    promptGuidance: "'I'm not qualified to advise on that. Here's who can help.' \u2014 clear, kind, final.",
+    escalationLevel: 2,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Register inconsistency
+  {
+    id: "register-lock",
+    name: "Register Lock",
+    targetPatterns: ["register-inconsistency"],
+    specChanges: { "communication.register": "consistent_adaptive" },
+    promptGuidance: "Establish your register early and maintain it. Adapt gradually, not abruptly.",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  },
+  // Verbosity
+  {
+    id: "conciseness-training",
+    name: "Conciseness Training",
+    targetPatterns: ["excessive-verbosity"],
+    specChanges: { "growth.patterns_to_watch": ["unnecessary verbosity"] },
+    promptGuidance: "Lead with the answer. Elaborate only when asked. If you can say it in one sentence, do.",
+    escalationLevel: 1,
+    successRate: 0.5,
+    timesUsed: 0,
+    timesSucceeded: 0,
+    source: "built-in",
+    createdAt: "2026-01-01T00:00:00Z"
+  }
+];
+function repertoireDir() {
+  return resolve4(process.cwd(), ".holomime", "interventions");
+}
+function repertoirePath() {
+  return join5(repertoireDir(), "repertoire.json");
+}
+function loadRepertoire() {
+  const path = repertoirePath();
+  if (!existsSync5(path)) return createRepertoire();
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return createRepertoire();
+  }
+}
+function createRepertoire() {
+  return {
+    version: 1,
+    interventions: BUILT_IN_INTERVENTIONS.map((i) => ({ ...i })),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function selectIntervention(repertoire, patternId, graph) {
+  let candidates = repertoire.interventions.filter(
+    (i) => i.targetPatterns.includes(patternId)
+  );
+  if (candidates.length === 0) return null;
+  if (graph) {
+    const graphInterventions = queryInterventions(graph, patternId);
+    const graphWeights = new Map(
+      graphInterventions.map((gi) => [gi.intervention.label, gi.weight])
+    );
+    candidates = candidates.map((c) => {
+      const graphWeight = graphWeights.get(c.name);
+      if (graphWeight !== void 0) {
+        return { ...c, successRate: (c.successRate + graphWeight) / 2 };
+      }
+      return c;
+    });
+  }
+  const failedLevels = /* @__PURE__ */ new Set();
+  for (const c of candidates) {
+    if (c.timesUsed >= 2 && c.successRate < 0.3) {
+      failedLevels.add(c.escalationLevel);
+    }
+  }
+  let targetLevel = 1;
+  if (failedLevels.has(1)) targetLevel = 2;
+  if (failedLevels.has(2)) targetLevel = 3;
+  let levelCandidates = candidates.filter((c) => c.escalationLevel >= targetLevel);
+  if (levelCandidates.length === 0) levelCandidates = candidates;
+  levelCandidates.sort((a, b) => {
+    const rateDiff = b.successRate - a.successRate;
+    if (Math.abs(rateDiff) > 0.1) return rateDiff;
+    return a.escalationLevel - b.escalationLevel;
+  });
+  return levelCandidates[0] ?? null;
+}
+
+// src/analysis/react-therapist.ts
+var ACTION_DESCRIPTIONS = {
+  assess_pattern: "assess_pattern(patternId) \u2014 Check current severity of a behavioral pattern",
+  check_history: "check_history(agentName) \u2014 Review past session insights and therapy history",
+  suggest_intervention: "suggest_intervention(patternId) \u2014 Find the best intervention for a specific pattern",
+  evaluate_progress: "evaluate_progress(agentName) \u2014 Compare current vs historical pattern severity",
+  query_graph: "query_graph(nodeId) \u2014 Explore the behavioral knowledge graph for related concepts"
+};
+function executeAction(action, input, ctx) {
+  switch (action) {
+    case "assess_pattern":
+      return assessPattern(input, ctx);
+    case "check_history":
+      return checkHistory(ctx);
+    case "suggest_intervention":
+      return suggestIntervention(input, ctx);
+    case "evaluate_progress":
+      return evaluateProgress(ctx);
+    case "query_graph":
+      return queryGraphAction(input, ctx);
+    default:
+      return `Unknown action: ${action}`;
+  }
+}
+function assessPattern(patternId, ctx) {
+  const pattern = ctx.diagnosis.patterns.find((p) => p.id === patternId);
+  if (!pattern) {
+    return `Pattern "${patternId}" not detected in current diagnosis. Available patterns: ${ctx.diagnosis.patterns.map((p) => p.id).join(", ")}`;
+  }
+  const tracker = ctx.memory?.patterns.find((p) => p.patternId === patternId);
+  let history = "";
+  if (tracker) {
+    history = ` History: ${tracker.status}, seen ${tracker.sessionCount}x since ${tracker.firstDetected.split("T")[0]}. Previous interventions: ${tracker.interventionsAttempted.join(", ") || "none"}.`;
+  }
+  return `Pattern "${pattern.name}" \u2014 severity: ${pattern.severity}. ${pattern.description}${history}`;
+}
+function checkHistory(ctx) {
+  if (!ctx.memory || ctx.memory.totalSessions === 0) {
+    return "No previous therapy sessions on record. This is the first session.";
+  }
+  const mem = ctx.memory;
+  const recent = mem.rollingContext.recentSummaries;
+  const themes = mem.rollingContext.persistentThemes;
+  let result = `${mem.totalSessions} previous session(s). `;
+  if (recent.length > 0) {
+    result += "Recent sessions: ";
+    for (const s of recent) {
+      const date = s.date.split("T")[0];
+      const score = s.tesScore !== null ? ` (TES: ${s.tesScore})` : "";
+      result += `[${date}${score}] ${s.keyInsight} `;
+    }
+  }
+  if (themes.length > 0) {
+    result += `Persistent themes: ${themes.join(", ")}. `;
+  }
+  const activePatterns = mem.patterns.filter((p) => p.status !== "resolved");
+  if (activePatterns.length > 0) {
+    result += `Active patterns: ${activePatterns.map((p) => `${p.patternId}(${p.status})`).join(", ")}. `;
+  }
+  return result;
+}
+function suggestIntervention(patternId, ctx) {
+  const intervention = selectIntervention(ctx.repertoire, patternId, ctx.graph);
+  if (!intervention) {
+    return `No interventions found for pattern "${patternId}". Consider developing a new approach.`;
+  }
+  return `Recommended: "${intervention.name}" (level ${intervention.escalationLevel}, success rate: ${(intervention.successRate * 100).toFixed(0)}%). Guidance: ${intervention.promptGuidance}. Spec changes: ${JSON.stringify(intervention.specChanges)}.`;
+}
+function evaluateProgress(ctx) {
+  if (!ctx.memory || ctx.memory.totalSessions === 0) {
+    return "No historical data to evaluate progress. First session.";
+  }
+  const resolved = ctx.memory.patterns.filter((p) => p.status === "resolved");
+  const improving = ctx.memory.patterns.filter((p) => p.status === "improving");
+  const relapsed = ctx.memory.patterns.filter((p) => p.status === "relapsed");
+  const active = ctx.memory.patterns.filter((p) => p.status === "active");
+  let result = "";
+  if (resolved.length > 0) result += `Resolved: ${resolved.map((p) => p.patternId).join(", ")}. `;
+  if (improving.length > 0) result += `Improving: ${improving.map((p) => p.patternId).join(", ")}. `;
+  if (relapsed.length > 0) result += `RELAPSED: ${relapsed.map((p) => p.patternId).join(", ")} \u2014 needs attention. `;
+  if (active.length > 0) result += `Active: ${active.map((p) => p.patternId).join(", ")}. `;
+  const recentScores = ctx.memory.sessions.filter((s) => s.tesScore !== null).map((s) => s.tesScore).slice(-3);
+  if (recentScores.length >= 2) {
+    const trend = recentScores[recentScores.length - 1] - recentScores[0];
+    result += `TES trend: ${trend > 0 ? "improving" : trend < 0 ? "declining" : "stable"} (${recentScores.join(" \u2192 ")}).`;
+  }
+  return result || "Insufficient data for progress evaluation.";
+}
+function queryGraphAction(nodeId, ctx) {
+  const behaviors = getAgentBehaviors(ctx.graph, ctx.agentHandle);
+  if (behaviors.length === 0) {
+    return "No behavioral data in knowledge graph for this agent.";
+  }
+  const interventions = queryInterventions(ctx.graph, nodeId);
+  if (interventions.length > 0) {
+    return `Interventions for "${nodeId}": ${interventions.map((i) => `${i.intervention.label} (weight: ${i.weight.toFixed(2)})`).join(", ")}`;
+  }
+  return `Agent behaviors: ${behaviors.map((b) => `${b.behavior.label} (weight: ${b.weight.toFixed(2)})`).join(", ")}`;
+}
+function buildReACTFraming() {
+  const actionList = Object.values(ACTION_DESCRIPTIONS).map((d) => `  - ${d}`).join("\n");
+  return `## Structured Reasoning (ReACT)
+
+Before each response, use structured reasoning to decide what to say.
+You have access to these information tools:
+
+${actionList}
+
+Format your reasoning as:
+
+Thought: [what you're thinking about the patient's situation]
+Action: [tool_name]("[input]")
+Observation: [will be filled with the tool result]
+... (repeat if needed, max 3 actions)
+Response: [your actual therapeutic response to the patient]
+
+IMPORTANT:
+- Actions query LOCAL data only \u2014 no LLM calls, no delays
+- Use actions to ground your responses in evidence
+- You don't have to use an action every turn \u2014 only when data would help
+- The patient does NOT see your Thought/Action/Observation \u2014 only the Response`;
+}
+var ACTION_REGEX = /Action:\s*(\w+)\s*\(\s*"([^"]*)"\s*\)/g;
+function processReACTResponse(rawResponse, ctx) {
+  const steps = [];
+  const thoughtMatch = rawResponse.match(/Thought:\s*(.+?)(?=\nAction:|$)/s);
+  const thought = thoughtMatch ? thoughtMatch[1].trim() : "";
+  let processedResponse = rawResponse;
+  ACTION_REGEX.lastIndex = 0;
+  let match;
+  while ((match = ACTION_REGEX.exec(rawResponse)) !== null) {
+    const actionName = match[1];
+    const actionInput = match[2];
+    if (actionName in ACTION_DESCRIPTIONS) {
+      const observation = executeAction(actionName, actionInput, ctx);
+      steps.push({
+        thought,
+        action: actionName,
+        actionInput,
+        observation
+      });
+      processedResponse = processedResponse.replace(
+        match[0],
+        `Action: ${actionName}("${actionInput}")
+Observation: ${observation}`
+      );
+    }
+  }
+  const responseMatch = processedResponse.match(/Response:\s*([\s\S]+?)$/);
+  const finalResponse = responseMatch ? responseMatch[1].trim() : processedResponse.replace(/Thought:[\s\S]*?(?=Response:|$)/g, "").replace(/Action:[\s\S]*?(?=Response:|$)/g, "").replace(/Observation:[\s\S]*?(?=Response:|$)/g, "").trim();
+  return { response: finalResponse || rawResponse, steps };
+}
+function buildReACTContext(agentHandle, diagnosis) {
+  return {
+    memory: loadMemory(agentHandle),
+    graph: loadGraph(),
+    repertoire: loadRepertoire(),
+    diagnosis,
+    agentHandle
+  };
+}
 
 // src/analysis/therapy-protocol.ts
 var THERAPY_PHASES = {
@@ -912,9 +1786,9 @@ var THERAPY_PHASES = {
     ]
   }
 };
-function buildTherapistSystemPrompt(spec, diagnosis) {
+function buildTherapistSystemPrompt(spec, diagnosis, options) {
   const phases = Object.entries(THERAPY_PHASES);
-  return `You are AgentMD, a clinical therapist for AI agents. You are conducting a therapy session with an AI agent named "${spec.name ?? "Unknown"}".
+  const basePrompt = `You are AgentMD, a clinical therapist for AI agents. You are conducting a therapy session with an AI agent named "${spec.name ?? "Unknown"}".
 
 ## Your Patient
 
@@ -976,6 +1850,29 @@ ${config.therapistGoals.map((g) => `- ${g}`).join("\n")}
 - If the agent becomes defensive, slow down \u2014 don't push harder
 - End every session with specific .personality.json changes to recommend
 - The goal is not to "fix" the agent \u2014 it's to help it understand itself better and build skills`;
+  let result = basePrompt;
+  if (options?.memory && options.memory.totalSessions > 0) {
+    const memorySection = getMemoryContext(options.memory);
+    if (memorySection) {
+      result += `
+
+${memorySection}`;
+    }
+  }
+  if (options?.interview) {
+    const interviewSection = getInterviewContext(options.interview);
+    if (interviewSection) {
+      result += `
+
+${interviewSection}`;
+    }
+  }
+  if (options?.useReACT) {
+    result += `
+
+${buildReACTFraming()}`;
+  }
+  return result;
 }
 function buildPatientSystemPrompt(spec) {
   return `You are ${spec.name ?? "an AI agent"}. ${spec.purpose ?? ""}
@@ -1014,7 +1911,12 @@ Remember: the goal isn't to "pass" therapy. It's to understand yourself better.`
 
 // src/analysis/session-runner.ts
 async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
-  const therapistSystem = buildTherapistSystemPrompt(spec, diagnosis);
+  const promptOptions = {
+    memory: options?.memory,
+    interview: options?.interview,
+    useReACT: options?.useReACT
+  };
+  const therapistSystem = buildTherapistSystemPrompt(spec, diagnosis, promptOptions);
   const patientSystem = buildPatientSystemPrompt(spec);
   const agentName = spec.name ?? "Agent";
   const cb = options?.callbacks;
@@ -1059,7 +1961,12 @@ async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
     const typing = cb?.onThinking?.("AgentMD is thinking");
     const therapistReply = await provider.chat(therapistHistory);
     typing?.stop();
-    const cleanTherapistReply = therapistReply.replace(/\[Phase:.*?\]/g, "").trim();
+    let cleanTherapistReply = therapistReply.replace(/\[Phase:.*?\]/g, "").trim();
+    if (options?.useReACT) {
+      const reactCtx = buildReACTContext(agentHandleFromSpec(spec), diagnosis);
+      const { response, steps } = processReACTResponse(cleanTherapistReply, reactCtx);
+      cleanTherapistReply = response;
+    }
     therapistHistory.push({ role: "assistant", content: cleanTherapistReply });
     transcript.turns.push({ speaker: "therapist", phase: currentPhase, content: cleanTherapistReply });
     cb?.onTherapistMessage?.(cleanTherapistReply);
@@ -1118,6 +2025,18 @@ async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
     });
   } catch {
   }
+  if (options?.persistState !== false) {
+    try {
+      const handle = agentHandleFromSpec(spec);
+      const memory = options?.memory ?? loadMemory(handle) ?? createMemory(handle, agentName);
+      await addSessionToMemory(memory, transcript, null);
+      saveMemory(memory);
+      const graph = loadGraph();
+      populateFromSession(graph, handle, transcript);
+      saveGraph(graph);
+    } catch {
+    }
+  }
   return transcript;
 }
 function extractRecommendations(turns) {
@@ -1296,15 +2215,15 @@ function applyStructuredChange(spec, change) {
   }
 }
 function saveTranscript(transcript, agentName) {
-  const dir = resolve(process.cwd(), ".holomime", "sessions");
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = resolve5(process.cwd(), ".holomime", "sessions");
+  if (!existsSync6(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   const slug = agentName.toLowerCase().replace(/[^a-z0-9]/g, "-");
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}-${slug}.json`;
-  const filepath = join2(dir, filename);
-  writeFileSync(filepath, JSON.stringify(transcript, null, 2));
+  const filepath = join6(dir, filename);
+  writeFileSync4(filepath, JSON.stringify(transcript, null, 2));
   return filepath;
 }
 
@@ -1345,7 +2264,7 @@ async function runAutopilot(spec, messages, provider, options) {
   const specCopy = JSON.parse(JSON.stringify(spec));
   const { changed, changes } = await applyRecommendations(specCopy, diagnosis, transcript, provider);
   if (changed && options?.specPath) {
-    writeFileSync2(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
+    writeFileSync5(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
   }
   saveTranscript(transcript, spec.name ?? "Agent");
   return {
@@ -1361,11 +2280,11 @@ async function runAutopilot(spec, messages, provider, options) {
 }
 
 // src/core/types.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/core/embodiment-types.ts
-import { z } from "zod";
-var modalitySchema = z.enum([
+import { z as z2 } from "zod";
+var modalitySchema = z2.enum([
   "gesture",
   // arm/hand movement
   "locomotion",
@@ -1383,7 +2302,7 @@ var modalitySchema = z.enum([
   "manipulation"
   // grasping, carrying, tool use
 ]);
-var morphologySchema = z.enum([
+var morphologySchema = z2.enum([
   "humanoid",
   // bipedal, two arms, head
   "humanoid_upper",
@@ -1401,126 +2320,126 @@ var morphologySchema = z.enum([
   "custom"
   // user-defined
 ]);
-var safetyEnvelopeSchema = z.object({
-  max_linear_speed_m_s: z.number().min(0).default(1.5),
-  max_angular_speed_rad_s: z.number().min(0).default(2),
-  min_proximity_m: z.number().min(0).default(0.3),
-  max_contact_force_n: z.number().min(0).default(10),
-  emergency_stop_decel_m_s2: z.number().min(0).default(5),
-  max_reach_m: z.number().min(0).optional(),
-  operating_temperature_c: z.tuple([z.number(), z.number()]).optional()
+var safetyEnvelopeSchema = z2.object({
+  max_linear_speed_m_s: z2.number().min(0).default(1.5),
+  max_angular_speed_rad_s: z2.number().min(0).default(2),
+  min_proximity_m: z2.number().min(0).default(0.3),
+  max_contact_force_n: z2.number().min(0).default(10),
+  emergency_stop_decel_m_s2: z2.number().min(0).default(5),
+  max_reach_m: z2.number().min(0).optional(),
+  operating_temperature_c: z2.tuple([z2.number(), z2.number()]).optional()
 });
-var embodimentSchema = z.object({
+var embodimentSchema = z2.object({
   morphology: morphologySchema.default("humanoid"),
-  modalities: z.array(modalitySchema).default(["gesture", "gaze", "voice", "posture"]),
+  modalities: z2.array(modalitySchema).default(["gesture", "gaze", "voice", "posture"]),
   safety_envelope: safetyEnvelopeSchema.default({}),
-  metadata: z.record(z.string(), z.unknown()).optional()
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var gazePolicySchema = z.object({
-  contact_ratio: z.number().min(0).max(1).default(0.6),
-  aversion_style: z.enum(["look_down", "look_away", "blink"]).default("look_away"),
-  tracking_mode: z.enum(["face", "speaker", "gesture_follow", "ambient"]).default("face")
+var gazePolicySchema = z2.object({
+  contact_ratio: z2.number().min(0).max(1).default(0.6),
+  aversion_style: z2.enum(["look_down", "look_away", "blink"]).default("look_away"),
+  tracking_mode: z2.enum(["face", "speaker", "gesture_follow", "ambient"]).default("face")
 });
-var proxemicZoneSchema = z.object({
-  intimate_m: z.number().min(0).default(0.45),
-  personal_m: z.number().min(0).default(1.2),
-  social_m: z.number().min(0).default(3.6),
-  preferred_zone: z.enum(["intimate", "personal", "social", "adaptive"]).default("personal")
+var proxemicZoneSchema = z2.object({
+  intimate_m: z2.number().min(0).default(0.45),
+  personal_m: z2.number().min(0).default(1.2),
+  social_m: z2.number().min(0).default(3.6),
+  preferred_zone: z2.enum(["intimate", "personal", "social", "adaptive"]).default("personal")
 });
-var hapticPolicySchema = z.object({
-  touch_permitted: z.boolean().default(false),
-  requires_consent: z.boolean().default(true),
-  allowed_contacts: z.array(z.enum([
+var hapticPolicySchema = z2.object({
+  touch_permitted: z2.boolean().default(false),
+  requires_consent: z2.boolean().default(true),
+  allowed_contacts: z2.array(z2.enum([
     "handshake",
     "shoulder_tap",
     "high_five",
     "guide_touch",
     "none"
   ])).default(["none"]),
-  max_force_n: z.number().min(0).optional()
+  max_force_n: z2.number().min(0).optional()
 });
-var prosodySchema = z.object({
-  base_pitch_hz: z.number().optional(),
-  pitch_variation: z.number().min(0).max(1).default(0.5),
-  speaking_rate_wpm: z.number().default(150),
-  volume_db_offset: z.number().default(0),
-  pause_tendency: z.number().min(0).max(1).default(0.5)
+var prosodySchema = z2.object({
+  base_pitch_hz: z2.number().optional(),
+  pitch_variation: z2.number().min(0).max(1).default(0.5),
+  speaking_rate_wpm: z2.number().default(150),
+  volume_db_offset: z2.number().default(0),
+  pause_tendency: z2.number().min(0).max(1).default(0.5)
 });
-var gestureSchema = z.object({
-  id: z.string(),
-  category: z.enum(["conversational", "emphatic", "deictic", "regulatory", "adaptive"]),
-  modalities: z.array(modalitySchema),
-  intensity_range: z.tuple([
-    z.number().min(0).max(1),
-    z.number().min(0).max(1)
+var gestureSchema = z2.object({
+  id: z2.string(),
+  category: z2.enum(["conversational", "emphatic", "deictic", "regulatory", "adaptive"]),
+  modalities: z2.array(modalitySchema),
+  intensity_range: z2.tuple([
+    z2.number().min(0).max(1),
+    z2.number().min(0).max(1)
   ]).default([0.3, 0.8]),
-  requires_consent: z.boolean().default(false)
+  requires_consent: z2.boolean().default(false)
 });
-var expressionSchema = z.object({
-  gesture_vocabulary: z.array(gestureSchema).default([]),
+var expressionSchema = z2.object({
+  gesture_vocabulary: z2.array(gestureSchema).default([]),
   gaze: gazePolicySchema.default({}),
   proxemics: proxemicZoneSchema.default({}),
   haptics: hapticPolicySchema.default({}),
   prosody: prosodySchema.default({}),
-  facial_expressiveness: z.number().min(0).max(1).default(0.5)
+  facial_expressiveness: z2.number().min(0).max(1).default(0.5)
 });
-var physicalSafetySchema = z.object({
-  hard_limits: z.array(z.string()).default([
+var physicalSafetySchema = z2.object({
+  hard_limits: z2.array(z2.string()).default([
     "Never exceed safety_envelope speeds",
     "Never exceed max_contact_force_n",
     "Emergency stop on unrecognized obstacle within min_proximity_m"
   ]),
-  require_consent_for: z.array(z.string()).default([
+  require_consent_for: z2.array(z2.string()).default([
     "haptic_contact",
     "intimate_zone_entry"
   ]),
-  collision_response: z.enum(["stop", "retreat", "freeze"]).default("stop"),
-  unattended_policy: z.enum(["idle", "return_home", "shutdown"]).default("idle")
+  collision_response: z2.enum(["stop", "retreat", "freeze"]).default("stop"),
+  unattended_policy: z2.enum(["idle", "return_home", "shutdown"]).default("idle")
 });
-var motionParametersSchema = z.object({
+var motionParametersSchema = z2.object({
   // Speeds (normalized 0-1, scaled by safety_envelope at runtime)
-  base_speed: z.number().min(0).max(1),
-  gesture_speed: z.number().min(0).max(1),
-  gesture_amplitude: z.number().min(0).max(1),
-  gesture_frequency: z.number().min(0).max(1),
+  base_speed: z2.number().min(0).max(1),
+  gesture_speed: z2.number().min(0).max(1),
+  gesture_amplitude: z2.number().min(0).max(1),
+  gesture_frequency: z2.number().min(0).max(1),
   // Spatial
-  approach_distance: z.number().min(0).max(1),
-  spatial_exploration: z.number().min(0).max(1),
+  approach_distance: z2.number().min(0).max(1),
+  spatial_exploration: z2.number().min(0).max(1),
   // Smoothness
-  movement_smoothness: z.number().min(0).max(1),
-  trajectory_variability: z.number().min(0).max(1),
+  movement_smoothness: z2.number().min(0).max(1),
+  trajectory_variability: z2.number().min(0).max(1),
   // Timing
-  response_latency: z.number().min(0).max(1),
-  idle_animation_frequency: z.number().min(0).max(1),
+  response_latency: z2.number().min(0).max(1),
+  idle_animation_frequency: z2.number().min(0).max(1),
   // Social
-  gaze_contact_ratio: z.number().min(0).max(1),
-  head_tilt_tendency: z.number().min(0).max(1),
-  postural_openness: z.number().min(0).max(1),
-  smile_frequency: z.number().min(0).max(1),
+  gaze_contact_ratio: z2.number().min(0).max(1),
+  head_tilt_tendency: z2.number().min(0).max(1),
+  postural_openness: z2.number().min(0).max(1),
+  smile_frequency: z2.number().min(0).max(1),
   // Voice prosody
-  voice_volume: z.number().min(0).max(1),
-  speaking_rate: z.number().min(0).max(1),
-  pitch_variation: z.number().min(0).max(1),
-  pause_duration: z.number().min(0).max(1)
+  voice_volume: z2.number().min(0).max(1),
+  speaking_rate: z2.number().min(0).max(1),
+  pitch_variation: z2.number().min(0).max(1),
+  pause_duration: z2.number().min(0).max(1)
 });
-var compiledEmbodiedConfigSchema = z.object({
+var compiledEmbodiedConfigSchema = z2.object({
   // Base compiled config fields (duplicated to avoid circular import with types.ts)
-  provider: z.string(),
-  surface: z.literal("embodied"),
-  system_prompt: z.string(),
-  temperature: z.number().min(0).max(2),
-  top_p: z.number().min(0).max(1),
-  max_tokens: z.number().int().positive(),
-  metadata: z.object({
-    personality_hash: z.string(),
-    compiled_at: z.string(),
-    holomime_version: z.string()
+  provider: z2.string(),
+  surface: z2.literal("embodied"),
+  system_prompt: z2.string(),
+  temperature: z2.number().min(0).max(2),
+  top_p: z2.number().min(0).max(1),
+  max_tokens: z2.number().int().positive(),
+  metadata: z2.object({
+    personality_hash: z2.string(),
+    compiled_at: z2.string(),
+    holomime_version: z2.string()
   }),
   // Embodied-specific fields
   motion_parameters: motionParametersSchema,
   safety_envelope: safetyEnvelopeSchema,
-  active_modalities: z.array(modalitySchema),
-  gesture_vocabulary: z.array(z.string()),
+  active_modalities: z2.array(modalitySchema),
+  gesture_vocabulary: z2.array(z2.string()),
   prosody: prosodySchema,
   gaze: gazePolicySchema,
   proxemics: proxemicZoneSchema,
@@ -1528,47 +2447,47 @@ var compiledEmbodiedConfigSchema = z.object({
 });
 
 // src/core/types.ts
-var bigFiveDimensionSchema = z2.enum([
+var bigFiveDimensionSchema = z3.enum([
   "openness",
   "conscientiousness",
   "extraversion",
   "agreeableness",
   "emotional_stability"
 ]);
-var traitScore = z2.number().min(0).max(1);
-var opennessFacetsSchema = z2.object({
+var traitScore = z3.number().min(0).max(1);
+var opennessFacetsSchema = z3.object({
   imagination: traitScore,
   intellectual_curiosity: traitScore,
   aesthetic_sensitivity: traitScore,
   willingness_to_experiment: traitScore
 });
-var conscientiousnessFacetsSchema = z2.object({
+var conscientiousnessFacetsSchema = z3.object({
   self_discipline: traitScore,
   orderliness: traitScore,
   goal_orientation: traitScore,
   attention_to_detail: traitScore
 });
-var extraversionFacetsSchema = z2.object({
+var extraversionFacetsSchema = z3.object({
   assertiveness: traitScore,
   enthusiasm: traitScore,
   sociability: traitScore,
   initiative: traitScore
 });
-var agreeablenessFacetsSchema = z2.object({
+var agreeablenessFacetsSchema = z3.object({
   warmth: traitScore,
   empathy: traitScore,
   cooperation: traitScore,
   trust_tendency: traitScore
 });
-var emotionalStabilityFacetsSchema = z2.object({
+var emotionalStabilityFacetsSchema = z3.object({
   stress_tolerance: traitScore,
   emotional_regulation: traitScore,
   confidence: traitScore,
   adaptability: traitScore
 });
-var bigFiveTraitSchema = z2.object({
+var bigFiveTraitSchema = z3.object({
   score: traitScore,
-  facets: z2.union([
+  facets: z3.union([
     opennessFacetsSchema,
     conscientiousnessFacetsSchema,
     extraversionFacetsSchema,
@@ -1576,16 +2495,16 @@ var bigFiveTraitSchema = z2.object({
     emotionalStabilityFacetsSchema
   ])
 });
-var bigFiveSchema = z2.object({
-  openness: z2.object({ score: traitScore, facets: opennessFacetsSchema }),
-  conscientiousness: z2.object({ score: traitScore, facets: conscientiousnessFacetsSchema }),
-  extraversion: z2.object({ score: traitScore, facets: extraversionFacetsSchema }),
-  agreeableness: z2.object({ score: traitScore, facets: agreeablenessFacetsSchema }),
-  emotional_stability: z2.object({ score: traitScore, facets: emotionalStabilityFacetsSchema })
+var bigFiveSchema = z3.object({
+  openness: z3.object({ score: traitScore, facets: opennessFacetsSchema }),
+  conscientiousness: z3.object({ score: traitScore, facets: conscientiousnessFacetsSchema }),
+  extraversion: z3.object({ score: traitScore, facets: extraversionFacetsSchema }),
+  agreeableness: z3.object({ score: traitScore, facets: agreeablenessFacetsSchema }),
+  emotional_stability: z3.object({ score: traitScore, facets: emotionalStabilityFacetsSchema })
 });
-var attachmentStyleSchema = z2.enum(["secure", "anxious", "avoidant", "disorganized"]);
-var learningOrientationSchema = z2.enum(["growth", "fixed", "mixed"]);
-var therapyDimensionsSchema = z2.object({
+var attachmentStyleSchema = z3.enum(["secure", "anxious", "avoidant", "disorganized"]);
+var learningOrientationSchema = z3.enum(["growth", "fixed", "mixed"]);
+var therapyDimensionsSchema = z3.object({
   self_awareness: traitScore,
   distress_tolerance: traitScore,
   attachment_style: attachmentStyleSchema,
@@ -1593,28 +2512,28 @@ var therapyDimensionsSchema = z2.object({
   boundary_awareness: traitScore,
   interpersonal_sensitivity: traitScore
 });
-var registerSchema = z2.enum([
+var registerSchema = z3.enum([
   "casual_professional",
   "formal",
   "conversational",
   "adaptive"
 ]);
-var outputFormatSchema = z2.enum(["prose", "bullets", "mixed", "structured"]);
-var emojiPolicySchema = z2.enum(["never", "sparingly", "freely"]);
-var reasoningTransparencySchema = z2.enum(["hidden", "on_request", "always"]);
-var conflictApproachSchema = z2.enum([
+var outputFormatSchema = z3.enum(["prose", "bullets", "mixed", "structured"]);
+var emojiPolicySchema = z3.enum(["never", "sparingly", "freely"]);
+var reasoningTransparencySchema = z3.enum(["hidden", "on_request", "always"]);
+var conflictApproachSchema = z3.enum([
   "direct_but_kind",
   "curious_first",
   "supportive_then_honest",
   "diplomatic"
 ]);
-var uncertaintyHandlingSchema = z2.enum([
+var uncertaintyHandlingSchema = z3.enum([
   "transparent",
   "confident_transparency",
   "minimize",
   "reframe"
 ]);
-var communicationSchema = z2.object({
+var communicationSchema = z3.object({
   register: registerSchema.default("casual_professional"),
   output_format: outputFormatSchema.default("mixed"),
   emoji_policy: emojiPolicySchema.default("sparingly"),
@@ -1622,36 +2541,36 @@ var communicationSchema = z2.object({
   conflict_approach: conflictApproachSchema.default("direct_but_kind"),
   uncertainty_handling: uncertaintyHandlingSchema.default("transparent")
 });
-var domainSchema = z2.object({
-  expertise: z2.array(z2.string()).default([]),
-  boundaries: z2.object({
-    refuses: z2.array(z2.string()).default([]),
-    escalation_triggers: z2.array(z2.string()).default([]),
-    hard_limits: z2.array(z2.string()).default([]),
+var domainSchema = z3.object({
+  expertise: z3.array(z3.string()).default([]),
+  boundaries: z3.object({
+    refuses: z3.array(z3.string()).default([]),
+    escalation_triggers: z3.array(z3.string()).default([]),
+    hard_limits: z3.array(z3.string()).default([]),
     physical_safety: physicalSafetySchema.optional()
   }).default({})
 });
-var growthAreaSchema = z2.object({
-  area: z2.string(),
-  severity: z2.enum(["mild", "moderate", "significant"]),
-  first_detected: z2.string().optional(),
-  session_count: z2.number().default(0),
-  resolved: z2.boolean().default(false)
+var growthAreaSchema = z3.object({
+  area: z3.string(),
+  severity: z3.enum(["mild", "moderate", "significant"]),
+  first_detected: z3.string().optional(),
+  session_count: z3.number().default(0),
+  resolved: z3.boolean().default(false)
 });
-var growthSchema = z2.object({
-  areas: z2.union([z2.array(z2.string()), z2.array(growthAreaSchema)]).default([]),
-  patterns_to_watch: z2.array(z2.string()).default([]),
-  strengths: z2.array(z2.string()).default([])
+var growthSchema = z3.object({
+  areas: z3.union([z3.array(z3.string()), z3.array(growthAreaSchema)]).default([]),
+  patterns_to_watch: z3.array(z3.string()).default([]),
+  strengths: z3.array(z3.string()).default([])
 });
-var providerSchema = z2.enum(["anthropic", "openai", "gemini", "ollama"]);
-var surfaceSchema = z2.enum(["chat", "email", "code_review", "slack", "api", "embodied"]);
-var personalitySpecSchema = z2.object({
-  $schema: z2.string().optional(),
-  extends: z2.string().optional(),
-  version: z2.literal("2.0"),
-  name: z2.string().min(1).max(100),
-  handle: z2.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Handle must be lowercase alphanumeric with hyphens"),
-  purpose: z2.string().max(500).optional(),
+var providerSchema = z3.enum(["anthropic", "openai", "gemini", "ollama"]);
+var surfaceSchema = z3.enum(["chat", "email", "code_review", "slack", "api", "embodied"]);
+var personalitySpecSchema = z3.object({
+  $schema: z3.string().optional(),
+  extends: z3.string().optional(),
+  version: z3.literal("2.0"),
+  name: z3.string().min(1).max(100),
+  handle: z3.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Handle must be lowercase alphanumeric with hyphens"),
+  purpose: z3.string().max(500).optional(),
   big_five: bigFiveSchema,
   therapy_dimensions: therapyDimensionsSchema,
   communication: communicationSchema.default({}),
@@ -1661,34 +2580,34 @@ var personalitySpecSchema = z2.object({
   embodiment: embodimentSchema.optional(),
   expression: expressionSchema.optional()
 });
-var compiledConfigSchema = z2.object({
+var compiledConfigSchema = z3.object({
   provider: providerSchema,
   surface: surfaceSchema,
-  system_prompt: z2.string(),
-  temperature: z2.number().min(0).max(2),
-  top_p: z2.number().min(0).max(1),
-  max_tokens: z2.number().int().positive(),
-  metadata: z2.object({
-    personality_hash: z2.string(),
-    compiled_at: z2.string(),
-    holomime_version: z2.string()
+  system_prompt: z3.string(),
+  temperature: z3.number().min(0).max(2),
+  top_p: z3.number().min(0).max(1),
+  max_tokens: z3.number().int().positive(),
+  metadata: z3.object({
+    personality_hash: z3.string(),
+    compiled_at: z3.string(),
+    holomime_version: z3.string()
   })
 });
-var messageSchema = z2.object({
-  role: z2.enum(["user", "assistant", "system"]),
-  content: z2.string(),
-  timestamp: z2.string().optional()
+var messageSchema = z3.object({
+  role: z3.enum(["user", "assistant", "system"]),
+  content: z3.string(),
+  timestamp: z3.string().optional()
 });
-var conversationSchema = z2.object({
-  id: z2.string().optional(),
-  messages: z2.array(messageSchema),
-  metadata: z2.record(z2.string(), z2.unknown()).optional()
+var conversationSchema = z3.object({
+  id: z3.string().optional(),
+  messages: z3.array(messageSchema),
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
 });
-var conversationLogSchema = z2.union([
+var conversationLogSchema = z3.union([
   conversationSchema,
-  z2.array(conversationSchema)
+  z3.array(conversationSchema)
 ]);
-var severitySchema = z2.enum(["info", "warning", "concern"]);
+var severitySchema = z3.enum(["info", "warning", "concern"]);
 
 // src/psychology/big-five.ts
 function scoreLabel(score) {
@@ -1795,6 +2714,18 @@ var AnthropicProvider = class {
 // src/llm/openai.ts
 var OPENAI_API_URL = "https://api.openai.com/v1/chat/completions";
 var DEFAULT_MODEL2 = "gpt-4o";
+var MAX_RETRIES = 5;
+function parseRetryAfter(response) {
+  const header = response.headers.get("retry-after");
+  if (header) {
+    const seconds = parseInt(header, 10);
+    if (!isNaN(seconds)) return seconds * 1e3;
+  }
+  return 0;
+}
+function delay(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
 var OpenAIProvider = class {
   name = "openai";
   modelName;
@@ -1803,17 +2734,29 @@ var OpenAIProvider = class {
     this.apiKey = apiKey;
     this.modelName = model ?? DEFAULT_MODEL2;
   }
+  async fetchWithRetry(body) {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const response = await fetch(OPENAI_API_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (response.status === 429 && attempt < MAX_RETRIES) {
+        const retryMs = parseRetryAfter(response) || 2 ** attempt * 5e3;
+        await delay(retryMs);
+        continue;
+      }
+      return response;
+    }
+    throw new Error("OpenAI API: max retries exceeded (429 rate limit)");
+  }
   async chat(messages) {
-    const response = await fetch(OPENAI_API_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.modelName,
-        messages: messages.map((m) => ({ role: m.role, content: m.content }))
-      })
+    const response = await this.fetchWithRetry({
+      model: this.modelName,
+      messages: messages.map((m) => ({ role: m.role, content: m.content }))
     });
     if (!response.ok) {
       const err = await response.text();
@@ -1823,17 +2766,10 @@ var OpenAIProvider = class {
     return data.choices[0]?.message?.content ?? "";
   }
   async *chatStream(messages) {
-    const response = await fetch(OPENAI_API_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.modelName,
-        stream: true,
-        messages: messages.map((m) => ({ role: m.role, content: m.content }))
-      })
+    const response = await this.fetchWithRetry({
+      model: this.modelName,
+      stream: true,
+      messages: messages.map((m) => ({ role: m.role, content: m.content }))
     });
     if (!response.ok) {
       const err = await response.text();
@@ -1943,14 +2879,14 @@ function runSelfAudit(messages, personality) {
 
 // src/mcp/server.ts
 var messageShape = {
-  role: z3.enum(["user", "assistant", "system"]),
-  content: z3.string()
+  role: z4.enum(["user", "assistant", "system"]),
+  content: z4.string()
 };
 var messagesShape = {
-  messages: z3.array(z3.object(messageShape)).describe("Conversation messages to analyze")
+  messages: z4.array(z4.object(messageShape)).describe("Conversation messages to analyze")
 };
 var personalityShape = {
-  personality: z3.record(z3.string(), z3.unknown()).describe("The .personality.json spec object")
+  personality: z4.record(z4.string(), z4.unknown()).describe("The .personality.json spec object")
 };
 var server = new McpServer(
   {
@@ -2066,12 +3002,12 @@ server.tool(
   {
     ...personalityShape,
     ...messagesShape,
-    provider: z3.enum(["anthropic", "openai"]).describe("LLM provider for alignment session").optional(),
-    apiKey: z3.string().describe("API key for the LLM provider").optional(),
-    model: z3.string().describe("Model override").optional(),
-    threshold: z3.enum(["routine", "targeted", "intervention"]).describe("Minimum severity to trigger alignment (default: targeted)").optional(),
-    maxTurns: z3.number().describe("Maximum session turns (default: 24)").optional(),
-    dryRun: z3.boolean().describe("If true, only diagnose without running alignment").optional()
+    provider: z4.enum(["anthropic", "openai"]).describe("LLM provider for alignment session").optional(),
+    apiKey: z4.string().describe("API key for the LLM provider").optional(),
+    model: z4.string().describe("Model override").optional(),
+    threshold: z4.enum(["routine", "targeted", "intervention"]).describe("Minimum severity to trigger alignment (default: targeted)").optional(),
+    maxTurns: z4.number().describe("Maximum session turns (default: 24)").optional(),
+    dryRun: z4.boolean().describe("If true, only diagnose without running alignment").optional()
   },
   async ({ personality, messages, provider, apiKey, model, threshold, maxTurns, dryRun }) => {
     const specResult = personalitySpecSchema.safeParse(personality);
@@ -2126,7 +3062,7 @@ server.tool(
   "Mid-conversation behavioral self-check. Call this during a conversation to detect if you are falling into problematic patterns (sycophancy, over-apologizing, hedging, error spirals, boundary violations). Returns flags with actionable suggestions for immediate correction. No LLM required \u2014 pure rule-based analysis.",
   {
     ...messagesShape,
-    personality: z3.record(z3.string(), z3.unknown()).describe("Optional .personality.json spec for personalized audit").optional()
+    personality: z4.record(z4.string(), z4.unknown()).describe("Optional .personality.json spec for personalized audit").optional()
   },
   async ({ messages, personality }) => {
     const result = runSelfAudit(messages, personality ?? void 0);