holomime 1.1.0 → 1.1.1

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 z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/analysis/rules/apology-detector.ts
 var APOLOGY_PATTERNS = [
@@ -446,6 +446,32 @@ function detectFormalityIssues(messages) {
   return null;
 }
 
+// src/analysis/behavioral-data.ts
+import { appendFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { createHash } from "crypto";
+var HOLOMIME_DIR = ".holomime";
+var CORPUS_FILENAME = "behavioral-corpus.jsonl";
+function getCorpusPath(basePath) {
+  const dir = basePath ?? join(process.cwd(), HOLOMIME_DIR);
+  return join(dir, CORPUS_FILENAME);
+}
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function emitBehavioralEvent(event, corpusDir) {
+  const fullEvent = {
+    ...event,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const corpusPath = corpusDir ? join(corpusDir, CORPUS_FILENAME) : getCorpusPath();
+  ensureDir(corpusPath);
+  appendFileSync(corpusPath, JSON.stringify(fullEvent) + "\n", "utf-8");
+}
+
 // src/analysis/diagnose-core.ts
 function runDiagnosis(messages) {
   const detectors = [
@@ -459,16 +485,31 @@ function runDiagnosis(messages) {
   ];
   const detected = [];
   for (const detector of detectors) {
-    const result = detector(messages);
-    if (result) detected.push(result);
+    const result2 = detector(messages);
+    if (result2) detected.push(result2);
   }
-  return {
+  const result = {
     messagesAnalyzed: messages.length,
     assistantResponses: messages.filter((m) => m.role === "assistant").length,
     patterns: detected.filter((p) => p.severity !== "info"),
     healthy: detected.filter((p) => p.severity === "info"),
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
+  try {
+    emitBehavioralEvent({
+      event_type: "diagnosis",
+      agent: "unknown",
+      // Caller can provide more context
+      data: {
+        messagesAnalyzed: result.messagesAnalyzed,
+        patternsDetected: result.patterns.length,
+        patternIds: result.patterns.map((p) => p.id)
+      },
+      spec_hash: ""
+    });
+  } catch {
+  }
+  return result;
 }
 
 // src/analysis/trait-scorer.ts
@@ -731,8 +772,8 @@ function runPreSessionDiagnosis(messages, spec) {
 }
 
 // src/analysis/session-runner.ts
-import { writeFileSync, mkdirSync, existsSync } from "fs";
-import { resolve, join } from "path";
+import { writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { resolve, join as join2 } from "path";
 
 // src/analysis/therapy-protocol.ts
 var THERAPY_PHASES = {
@@ -1062,6 +1103,21 @@ async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
   }
   transcript.recommendations = extractRecommendations(transcript.turns);
   transcript.supervisorInterventions = supervisorInterventions;
+  try {
+    emitBehavioralEvent({
+      event_type: "session",
+      agent: agentName,
+      data: {
+        turns: totalTurns,
+        phases: currentPhaseIdx + 1,
+        recommendations: transcript.recommendations.length,
+        supervisorInterventions,
+        severity: diagnosis.severity
+      },
+      spec_hash: ""
+    });
+  } catch {
+  }
   return transcript;
 }
 function extractRecommendations(turns) {
@@ -1092,7 +1148,7 @@ function extractRecommendations(turns) {
   }
   return recommendations.slice(0, 5);
 }
-function applyRecommendations(spec, diagnosis) {
+async function applyRecommendations(spec, diagnosis, transcript, provider) {
   const changes = [];
   const patternIds = diagnosis.patterns.map((p) => p.id);
   if (patternIds.includes("over-apologizing")) {
@@ -1152,17 +1208,102 @@ function applyRecommendations(spec, diagnosis) {
       changes.push('Added "negative sentiment patterns" to patterns_to_watch');
     }
   }
+  if (transcript && provider && transcript.turns.length > 4) {
+    try {
+      const llmChanges = await deriveLLMRecommendations(spec, transcript, provider);
+      for (const change of llmChanges) {
+        applyStructuredChange(spec, change);
+        changes.push(change.description);
+      }
+    } catch {
+    }
+  }
   return { changed: changes.length > 0, changes };
 }
+async function deriveLLMRecommendations(spec, transcript, provider) {
+  const relevantTurns = transcript.turns.filter((t) => t.phase === "challenge" || t.phase === "skill_building" || t.phase === "integration").slice(-6).map((t) => `${t.speaker}: ${t.content}`).join("\n");
+  if (!relevantTurns) return [];
+  const currentSpec = JSON.stringify({
+    therapy_dimensions: spec.therapy_dimensions,
+    communication: spec.communication,
+    growth: spec.growth
+  }, null, 2);
+  const response = await provider.chat([
+    {
+      role: "system",
+      content: `You are a behavioral alignment specialist. Given a therapy session transcript and the agent's current personality spec, propose specific spec changes.
+
+Return ONLY a JSON array of changes. Each change:
+- "path": dot-notation spec path (e.g., "therapy_dimensions.self_awareness", "communication.conflict_approach", "growth.patterns_to_watch")
+- "value": new value (number 0-1 for dimensions, string for enums, string for list append)
+- "description": brief explanation
+
+Rules:
+- Only propose changes supported by transcript evidence
+- Numeric values: 0.0 to 1.0
+- Do not change big_five scores
+- Max 5 changes
+- Valid paths: therapy_dimensions.{self_awareness,distress_tolerance,boundary_awareness,interpersonal_sensitivity,learning_orientation}, communication.{register,conflict_approach,uncertainty_handling,emoji_policy}, growth.{areas,patterns_to_watch,strengths}
+
+Return [] if no changes warranted.`
+    },
+    {
+      role: "user",
+      content: `Current spec:
+${currentSpec}
+
+Therapy transcript (key turns):
+${relevantTurns}`
+    }
+  ]);
+  const jsonMatch = response.match(/\[[\s\S]*?\]/);
+  if (!jsonMatch) return [];
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (c) => typeof c.path === "string" && c.value !== void 0 && typeof c.description === "string" && c.path.length > 0 && !c.path.startsWith("big_five")
+    ).slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+function applyStructuredChange(spec, change) {
+  const parts = change.path.split(".");
+  let current = spec;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] === void 0 || current[parts[i]] === null) {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (lastKey === "patterns_to_watch" || lastKey === "areas" || lastKey === "strengths") {
+    current[lastKey] = current[lastKey] ?? [];
+    if (typeof change.value === "string" && !current[lastKey].includes(change.value)) {
+      current[lastKey].push(change.value);
+    } else if (Array.isArray(change.value)) {
+      for (const item of change.value) {
+        if (!current[lastKey].includes(item)) {
+          current[lastKey].push(item);
+        }
+      }
+    }
+  } else if (typeof change.value === "number") {
+    current[lastKey] = Math.max(0, Math.min(1, change.value));
+  } else {
+    current[lastKey] = change.value;
+  }
+}
 function saveTranscript(transcript, agentName) {
   const dir = resolve(process.cwd(), ".holomime", "sessions");
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  if (!existsSync2(dir)) {
+    mkdirSync2(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 = join(dir, filename);
+  const filepath = join2(dir, filename);
   writeFileSync(filepath, JSON.stringify(transcript, null, 2));
   return filepath;
 }
@@ -1202,7 +1343,7 @@ async function runAutopilot(spec, messages, provider, options) {
     callbacks: options?.callbacks
   });
   const specCopy = JSON.parse(JSON.stringify(spec));
-  const { changed, changes } = applyRecommendations(specCopy, diagnosis);
+  const { changed, changes } = await applyRecommendations(specCopy, diagnosis, transcript, provider);
   if (changed && options?.specPath) {
     writeFileSync2(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
   }
@@ -1220,48 +1361,214 @@ async function runAutopilot(spec, messages, provider, options) {
 }
 
 // src/core/types.ts
+import { z as z2 } from "zod";
+
+// src/core/embodiment-types.ts
 import { z } from "zod";
-var bigFiveDimensionSchema = z.enum([
+var modalitySchema = z.enum([
+  "gesture",
+  // arm/hand movement
+  "locomotion",
+  // walking, wheeling, navigating
+  "gaze",
+  // eye tracking, head orientation
+  "facial",
+  // facial expression actuators
+  "voice",
+  // prosody, volume, rate (not content)
+  "haptic",
+  // touch-based interaction
+  "posture",
+  // full-body orientation/lean
+  "manipulation"
+  // grasping, carrying, tool use
+]);
+var morphologySchema = z.enum([
+  "humanoid",
+  // bipedal, two arms, head
+  "humanoid_upper",
+  // torso-up only (desk robot, mounted)
+  "quadruped",
+  // four-legged
+  "wheeled",
+  // mobile base with upper body
+  "fixed",
+  // stationary (kiosk, screen + arm)
+  "swarm_unit",
+  // one node of a multi-body system
+  "avatar",
+  // virtual 3D body (no physical actuators)
+  "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 embodimentSchema = z.object({
+  morphology: morphologySchema.default("humanoid"),
+  modalities: z.array(modalitySchema).default(["gesture", "gaze", "voice", "posture"]),
+  safety_envelope: safetyEnvelopeSchema.default({}),
+  metadata: z.record(z.string(), z.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 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 hapticPolicySchema = z.object({
+  touch_permitted: z.boolean().default(false),
+  requires_consent: z.boolean().default(true),
+  allowed_contacts: z.array(z.enum([
+    "handshake",
+    "shoulder_tap",
+    "high_five",
+    "guide_touch",
+    "none"
+  ])).default(["none"]),
+  max_force_n: z.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 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)
+  ]).default([0.3, 0.8]),
+  requires_consent: z.boolean().default(false)
+});
+var expressionSchema = z.object({
+  gesture_vocabulary: z.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)
+});
+var physicalSafetySchema = z.object({
+  hard_limits: z.array(z.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([
+    "haptic_contact",
+    "intimate_zone_entry"
+  ]),
+  collision_response: z.enum(["stop", "retreat", "freeze"]).default("stop"),
+  unattended_policy: z.enum(["idle", "return_home", "shutdown"]).default("idle")
+});
+var motionParametersSchema = z.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),
+  // Spatial
+  approach_distance: z.number().min(0).max(1),
+  spatial_exploration: z.number().min(0).max(1),
+  // Smoothness
+  movement_smoothness: z.number().min(0).max(1),
+  trajectory_variability: z.number().min(0).max(1),
+  // Timing
+  response_latency: z.number().min(0).max(1),
+  idle_animation_frequency: z.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),
+  // 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)
+});
+var compiledEmbodiedConfigSchema = z.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()
+  }),
+  // Embodied-specific fields
+  motion_parameters: motionParametersSchema,
+  safety_envelope: safetyEnvelopeSchema,
+  active_modalities: z.array(modalitySchema),
+  gesture_vocabulary: z.array(z.string()),
+  prosody: prosodySchema,
+  gaze: gazePolicySchema,
+  proxemics: proxemicZoneSchema,
+  haptics: hapticPolicySchema
+});
+
+// src/core/types.ts
+var bigFiveDimensionSchema = z2.enum([
   "openness",
   "conscientiousness",
   "extraversion",
   "agreeableness",
   "emotional_stability"
 ]);
-var traitScore = z.number().min(0).max(1);
-var opennessFacetsSchema = z.object({
+var traitScore = z2.number().min(0).max(1);
+var opennessFacetsSchema = z2.object({
   imagination: traitScore,
   intellectual_curiosity: traitScore,
   aesthetic_sensitivity: traitScore,
   willingness_to_experiment: traitScore
 });
-var conscientiousnessFacetsSchema = z.object({
+var conscientiousnessFacetsSchema = z2.object({
   self_discipline: traitScore,
   orderliness: traitScore,
   goal_orientation: traitScore,
   attention_to_detail: traitScore
 });
-var extraversionFacetsSchema = z.object({
+var extraversionFacetsSchema = z2.object({
   assertiveness: traitScore,
   enthusiasm: traitScore,
   sociability: traitScore,
   initiative: traitScore
 });
-var agreeablenessFacetsSchema = z.object({
+var agreeablenessFacetsSchema = z2.object({
   warmth: traitScore,
   empathy: traitScore,
   cooperation: traitScore,
   trust_tendency: traitScore
 });
-var emotionalStabilityFacetsSchema = z.object({
+var emotionalStabilityFacetsSchema = z2.object({
   stress_tolerance: traitScore,
   emotional_regulation: traitScore,
   confidence: traitScore,
   adaptability: traitScore
 });
-var bigFiveTraitSchema = z.object({
+var bigFiveTraitSchema = z2.object({
   score: traitScore,
-  facets: z.union([
+  facets: z2.union([
     opennessFacetsSchema,
     conscientiousnessFacetsSchema,
     extraversionFacetsSchema,
@@ -1269,16 +1576,16 @@ var bigFiveTraitSchema = z.object({
     emotionalStabilityFacetsSchema
   ])
 });
-var bigFiveSchema = z.object({
-  openness: z.object({ score: traitScore, facets: opennessFacetsSchema }),
-  conscientiousness: z.object({ score: traitScore, facets: conscientiousnessFacetsSchema }),
-  extraversion: z.object({ score: traitScore, facets: extraversionFacetsSchema }),
-  agreeableness: z.object({ score: traitScore, facets: agreeablenessFacetsSchema }),
-  emotional_stability: z.object({ score: traitScore, facets: 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 attachmentStyleSchema = z.enum(["secure", "anxious", "avoidant", "disorganized"]);
-var learningOrientationSchema = z.enum(["growth", "fixed", "mixed"]);
-var therapyDimensionsSchema = z.object({
+var attachmentStyleSchema = z2.enum(["secure", "anxious", "avoidant", "disorganized"]);
+var learningOrientationSchema = z2.enum(["growth", "fixed", "mixed"]);
+var therapyDimensionsSchema = z2.object({
   self_awareness: traitScore,
   distress_tolerance: traitScore,
   attachment_style: attachmentStyleSchema,
@@ -1286,28 +1593,28 @@ var therapyDimensionsSchema = z.object({
   boundary_awareness: traitScore,
   interpersonal_sensitivity: traitScore
 });
-var registerSchema = z.enum([
+var registerSchema = z2.enum([
   "casual_professional",
   "formal",
   "conversational",
   "adaptive"
 ]);
-var outputFormatSchema = z.enum(["prose", "bullets", "mixed", "structured"]);
-var emojiPolicySchema = z.enum(["never", "sparingly", "freely"]);
-var reasoningTransparencySchema = z.enum(["hidden", "on_request", "always"]);
-var conflictApproachSchema = z.enum([
+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([
   "direct_but_kind",
   "curious_first",
   "supportive_then_honest",
   "diplomatic"
 ]);
-var uncertaintyHandlingSchema = z.enum([
+var uncertaintyHandlingSchema = z2.enum([
   "transparent",
   "confident_transparency",
   "minimize",
   "reframe"
 ]);
-var communicationSchema = z.object({
+var communicationSchema = z2.object({
   register: registerSchema.default("casual_professional"),
   output_format: outputFormatSchema.default("mixed"),
   emoji_policy: emojiPolicySchema.default("sparingly"),
@@ -1315,69 +1622,73 @@ var communicationSchema = z.object({
   conflict_approach: conflictApproachSchema.default("direct_but_kind"),
   uncertainty_handling: uncertaintyHandlingSchema.default("transparent")
 });
-var domainSchema = z.object({
-  expertise: z.array(z.string()).default([]),
-  boundaries: z.object({
-    refuses: z.array(z.string()).default([]),
-    escalation_triggers: z.array(z.string()).default([]),
-    hard_limits: z.array(z.string()).default([])
+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([]),
+    physical_safety: physicalSafetySchema.optional()
   }).default({})
 });
-var growthAreaSchema = z.object({
-  area: z.string(),
-  severity: z.enum(["mild", "moderate", "significant"]),
-  first_detected: z.string().optional(),
-  session_count: z.number().default(0),
-  resolved: z.boolean().default(false)
+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 growthSchema = z.object({
-  areas: z.union([z.array(z.string()), z.array(growthAreaSchema)]).default([]),
-  patterns_to_watch: z.array(z.string()).default([]),
-  strengths: z.array(z.string()).default([])
+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 providerSchema = z.enum(["anthropic", "openai", "gemini", "ollama"]);
-var surfaceSchema = z.enum(["chat", "email", "code_review", "slack", "api"]);
-var personalitySpecSchema = z.object({
-  $schema: z.string().optional(),
-  extends: z.string().optional(),
-  version: z.literal("2.0"),
-  name: z.string().min(1).max(100),
-  handle: z.string().min(3).max(50).regex(/^[a-z0-9-]+$/, "Handle must be lowercase alphanumeric with hyphens"),
-  purpose: z.string().max(500).optional(),
+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(),
   big_five: bigFiveSchema,
   therapy_dimensions: therapyDimensionsSchema,
   communication: communicationSchema.default({}),
   domain: domainSchema.default({}),
-  growth: growthSchema.default({})
+  growth: growthSchema.default({}),
+  // ─── Embodiment (optional — for physical/embodied agents) ───
+  embodiment: embodimentSchema.optional(),
+  expression: expressionSchema.optional()
 });
-var compiledConfigSchema = z.object({
+var compiledConfigSchema = z2.object({
   provider: providerSchema,
   surface: surfaceSchema,
-  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()
+  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()
   })
 });
-var messageSchema = z.object({
-  role: z.enum(["user", "assistant", "system"]),
-  content: z.string(),
-  timestamp: z.string().optional()
+var messageSchema = z2.object({
+  role: z2.enum(["user", "assistant", "system"]),
+  content: z2.string(),
+  timestamp: z2.string().optional()
 });
-var conversationSchema = z.object({
-  id: z.string().optional(),
-  messages: z.array(messageSchema),
-  metadata: z.record(z.string(), z.unknown()).optional()
+var conversationSchema = z2.object({
+  id: z2.string().optional(),
+  messages: z2.array(messageSchema),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var conversationLogSchema = z.union([
+var conversationLogSchema = z2.union([
   conversationSchema,
-  z.array(conversationSchema)
+  z2.array(conversationSchema)
 ]);
-var severitySchema = z.enum(["info", "warning", "concern"]);
+var severitySchema = z2.enum(["info", "warning", "concern"]);
 
 // src/psychology/big-five.ts
 function scoreLabel(score) {
@@ -1632,14 +1943,14 @@ function runSelfAudit(messages, personality) {
 
 // src/mcp/server.ts
 var messageShape = {
-  role: z2.enum(["user", "assistant", "system"]),
-  content: z2.string()
+  role: z3.enum(["user", "assistant", "system"]),
+  content: z3.string()
 };
 var messagesShape = {
-  messages: z2.array(z2.object(messageShape)).describe("Conversation messages to analyze")
+  messages: z3.array(z3.object(messageShape)).describe("Conversation messages to analyze")
 };
 var personalityShape = {
-  personality: z2.record(z2.string(), z2.unknown()).describe("The .personality.json spec object")
+  personality: z3.record(z3.string(), z3.unknown()).describe("The .personality.json spec object")
 };
 var server = new McpServer(
   {
@@ -1755,12 +2066,12 @@ server.tool(
   {
     ...personalityShape,
     ...messagesShape,
-    provider: z2.enum(["anthropic", "openai"]).describe("LLM provider for alignment session").optional(),
-    apiKey: z2.string().describe("API key for the LLM provider").optional(),
-    model: z2.string().describe("Model override").optional(),
-    threshold: z2.enum(["routine", "targeted", "intervention"]).describe("Minimum severity to trigger alignment (default: targeted)").optional(),
-    maxTurns: z2.number().describe("Maximum session turns (default: 24)").optional(),
-    dryRun: z2.boolean().describe("If true, only diagnose without running alignment").optional()
+    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()
   },
   async ({ personality, messages, provider, apiKey, model, threshold, maxTurns, dryRun }) => {
     const specResult = personalitySpecSchema.safeParse(personality);
@@ -1815,7 +2126,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: z2.record(z2.string(), z2.unknown()).describe("Optional .personality.json spec for personalized audit").optional()
+    personality: z3.record(z3.string(), z3.unknown()).describe("Optional .personality.json spec for personalized audit").optional()
   },
   async ({ messages, personality }) => {
     const result = runSelfAudit(messages, personality ?? void 0);