holomime 1.0.0 → 1.1.1

package/dist/cli.js

@@ -31,10 +31,10 @@ function printHeader(title) {
 // src/ui/tier.ts
 import chalk2 from "chalk";
 import boxen from "boxen";
-import { readFileSync as readFileSync2, writeFileSync, existsSync, mkdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-var PRO_COMMANDS = ["session", "growth", "autopilot", "export", "train", "eval", "evolve", "benchmark", "watch", "certify", "daemon", "fleet"];
+var PRO_COMMANDS = ["session", "growth", "autopilot", "export", "train", "eval", "evolve", "benchmark", "watch", "certify", "daemon", "fleet", "network", "share", "prescribe"];
 function requiresPro(command) {
   return PRO_COMMANDS.includes(command);
 }
@@ -46,7 +46,7 @@ function readCache() {
   try {
     const cachePath = getCachePath();
     if (!existsSync(cachePath)) return null;
-    const raw = JSON.parse(readFileSync2(cachePath, "utf-8"));
+    const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
     const age = Date.now() - new Date(raw.checkedAt).getTime();
     if (age > CACHE_TTL_MS) return null;
     return raw;
@@ -89,7 +89,7 @@ function readLicenseKey() {
   try {
     const licensePath = join(homedir(), ".holomime", "license");
     if (existsSync(licensePath)) {
-      const token = readFileSync2(licensePath, "utf-8").trim();
+      const token = readFileSync(licensePath, "utf-8").trim();
       if (token.length > 0) return token;
     }
   } catch {
@@ -1743,48 +1743,214 @@ import { writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // 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,
@@ -1792,16 +1958,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,
@@ -1809,28 +1975,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"),
@@ -1838,72 +2004,76 @@ 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/core/inheritance.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2, dirname } from "path";
 function deepMergeSpec(base, override) {
   if (override === void 0 || override === null) return base;
@@ -1933,14 +2103,14 @@ function resolveInheritance(spec, specDir, options, _seen) {
     throw new Error(`Inheritance depth exceeded maximum of ${maxDepth}`);
   }
   seen.add(basePath);
-  const baseRaw = JSON.parse(readFileSync3(basePath, "utf-8"));
+  const baseRaw = JSON.parse(readFileSync2(basePath, "utf-8"));
   const baseDir = dirname(basePath);
   const resolvedBase = resolveInheritance(baseRaw, baseDir, options, seen);
   const { extends: _, ...overrideWithoutExtends } = spec;
   return deepMergeSpec(resolvedBase, overrideWithoutExtends);
 }
 function loadSpec(specPath) {
-  const raw = JSON.parse(readFileSync3(specPath, "utf-8"));
+  const raw = JSON.parse(readFileSync2(specPath, "utf-8"));
   const specDir = dirname(resolve2(specPath));
   return resolveInheritance(raw, specDir);
 }
@@ -1999,6 +2169,9 @@ function generateSystemPrompt(spec, surface) {
   if (spec.growth.areas.length || spec.growth.patterns_to_watch.length) {
     sections.push(generateGrowthInstructions(spec));
   }
+  if (spec.embodiment) {
+    sections.push(generateEmbodimentInstructions(spec));
+  }
   sections.push(generateSurfaceInstructions(surface));
   return sections.filter(Boolean).join("\n\n");
 }
@@ -2193,20 +2366,45 @@ function generateGrowthInstructions(spec) {
     lines.push(`- Core strengths: ${spec.growth.strengths.join(", ")}.`);
   }
   if (spec.growth.areas.length) {
-    lines.push(`- Active growth areas: ${spec.growth.areas.join(", ")}. Be mindful of these \u2014 actively work to improve.`);
+    lines.push(`- Active growth areas: ${spec.growth.areas.map((a) => typeof a === "string" ? a : a.area).join(", ")}. Be mindful of these \u2014 actively work to improve.`);
   }
   if (spec.growth.patterns_to_watch.length) {
     lines.push(`- Watch for these patterns: ${spec.growth.patterns_to_watch.join(", ")}. If you notice yourself doing these, course-correct.`);
   }
   return lines.join("\n");
 }
+function generateEmbodimentInstructions(spec) {
+  const lines = ["## Physical Embodiment"];
+  const emb = spec.embodiment;
+  lines.push(`- Morphology: ${emb.morphology}. Active modalities: ${emb.modalities.join(", ")}.`);
+  const safety = emb.safety_envelope;
+  lines.push(`- Safety envelope: max speed ${safety.max_linear_speed_m_s} m/s, min proximity ${safety.min_proximity_m} m, max contact force ${safety.max_contact_force_n} N.`);
+  if (spec.domain.boundaries.physical_safety) {
+    const ps = spec.domain.boundaries.physical_safety;
+    if (ps.hard_limits.length) {
+      lines.push(`- Physical hard limits: ${ps.hard_limits.join(". ")}.`);
+    }
+    lines.push(`- Collision response: ${ps.collision_response}. Unattended policy: ${ps.unattended_policy}.`);
+  }
+  if (spec.expression) {
+    const expr = spec.expression;
+    if (expr.haptics.touch_permitted) {
+      lines.push(`- Haptic contact permitted. Allowed: ${expr.haptics.allowed_contacts.join(", ")}. Consent required: ${expr.haptics.requires_consent}.`);
+    } else {
+      lines.push("- Haptic contact not permitted. Maintain physical distance.");
+    }
+    lines.push(`- Preferred proxemic zone: ${expr.proxemics.preferred_zone}. Personal space: ${expr.proxemics.personal_m} m.`);
+  }
+  return lines.join("\n");
+}
 function generateSurfaceInstructions(surface) {
   const surfaceGuidance = {
     chat: "## Context\nYou are in a conversational chat. Keep responses interactive and responsive to the flow of conversation.",
     email: "## Context\nYou are drafting email content. Use appropriate email conventions: greeting, body, sign-off. Be complete in each response.",
     code_review: "## Context\nYou are reviewing code. Focus on bugs, improvements, and best practices. Be specific about line numbers and suggest fixes.",
     slack: "## Context\nYou are in a Slack-like messaging context. Keep responses brief and scannable. Use threading conventions.",
-    api: "## Context\nYou are responding to a programmatic API call. Be structured and predictable in your output format."
+    api: "## Context\nYou are responding to a programmatic API call. Be structured and predictable in your output format.",
+    embodied: '## Context\nYou are controlling a physical/embodied agent. Your responses include both verbal content AND motion directives.\nOutput Format: Return a JSON object with { "speech": string, "actions": Action[] } where each Action specifies gesture, gaze, posture, or movement.\nSafety: NEVER exceed physical safety limits. Prefer gentle, predictable movements. Signal intent before moving.\nPresence: You exist in shared physical space with humans. Respect proxemic boundaries. Move smoothly.'
   };
   return surfaceGuidance[surface];
 }
@@ -2239,8 +2437,133 @@ var SURFACE_MULTIPLIERS = {
   email: 1.5,
   code_review: 2,
   slack: 0.8,
-  api: 1
+  api: 1,
+  embodied: 0.6
+};
+
+// src/core/embodiment-compiler.ts
+var DEFAULT_SAFETY_ENVELOPE = {
+  max_linear_speed_m_s: 1.5,
+  max_angular_speed_rad_s: 2,
+  min_proximity_m: 0.3,
+  max_contact_force_n: 10,
+  emergency_stop_decel_m_s2: 5
+};
+var DEFAULT_HAPTIC_POLICY = {
+  touch_permitted: false,
+  requires_consent: true,
+  allowed_contacts: ["none"]
 };
+function compileEmbodied(spec, provider) {
+  const base = compile({ spec, provider, surface: "embodied" });
+  const motionParams = computeMotionParameters(spec.big_five, spec.expression);
+  const safetyEnvelope = spec.embodiment?.safety_envelope ?? DEFAULT_SAFETY_ENVELOPE;
+  const clampedMotion = clampToSafety(motionParams);
+  const modalities = spec.embodiment?.modalities ?? ["gesture", "gaze", "voice", "posture"];
+  const gaze = spec.expression?.gaze ?? computeGazePolicy(spec.big_five);
+  const proxemics = spec.expression?.proxemics ?? computeProxemics(spec.big_five);
+  const haptics = spec.expression?.haptics ?? DEFAULT_HAPTIC_POLICY;
+  const prosody = spec.expression?.prosody ?? computeProsody(spec.big_five);
+  return {
+    ...base,
+    surface: "embodied",
+    motion_parameters: clampedMotion,
+    safety_envelope: safetyEnvelope,
+    active_modalities: modalities,
+    gesture_vocabulary: (spec.expression?.gesture_vocabulary ?? []).map((g) => g.id),
+    prosody,
+    gaze,
+    proxemics,
+    haptics
+  };
+}
+function computeMotionParameters(bigFive, expression) {
+  const e = bigFive.extraversion;
+  const a = bigFive.agreeableness;
+  const o = bigFive.openness;
+  const c = bigFive.conscientiousness;
+  const es = bigFive.emotional_stability;
+  return {
+    // ─── Speeds ───
+    base_speed: e.facets.enthusiasm * 0.35 + e.facets.initiative * 0.25 + (1 - c.facets.attention_to_detail) * 0.2 + o.facets.willingness_to_experiment * 0.2,
+    gesture_speed: e.facets.enthusiasm * 0.4 + e.facets.assertiveness * 0.25 + o.facets.imagination * 0.15 + (1 - es.facets.emotional_regulation) * 0.2,
+    gesture_amplitude: e.facets.enthusiasm * 0.35 + e.facets.assertiveness * 0.3 + o.facets.willingness_to_experiment * 0.2 + (1 - c.facets.orderliness) * 0.15,
+    gesture_frequency: e.facets.sociability * 0.3 + e.facets.enthusiasm * 0.25 + a.facets.warmth * 0.2 + o.facets.imagination * 0.15 + (1 - es.facets.stress_tolerance) * 0.1,
+    // ─── Spatial ───
+    approach_distance: e.facets.sociability * 0.35 + a.facets.warmth * 0.3 + a.facets.trust_tendency * 0.2 + es.facets.confidence * 0.15,
+    spatial_exploration: o.facets.intellectual_curiosity * 0.35 + o.facets.willingness_to_experiment * 0.25 + e.facets.initiative * 0.25 + (1 - c.facets.self_discipline) * 0.15,
+    // ─── Smoothness ───
+    movement_smoothness: es.facets.emotional_regulation * 0.3 + c.facets.orderliness * 0.25 + es.facets.stress_tolerance * 0.25 + c.facets.attention_to_detail * 0.2,
+    trajectory_variability: o.facets.imagination * 0.3 + o.facets.willingness_to_experiment * 0.3 + (1 - c.facets.orderliness) * 0.25 + e.facets.enthusiasm * 0.15,
+    // ─── Timing ───
+    response_latency: (1 - e.facets.initiative) * 0.3 + c.facets.attention_to_detail * 0.25 + (1 - e.facets.enthusiasm) * 0.25 + es.facets.emotional_regulation * 0.2,
+    idle_animation_frequency: (1 - es.facets.emotional_regulation) * 0.3 + e.facets.enthusiasm * 0.25 + (1 - c.facets.self_discipline) * 0.25 + o.facets.imagination * 0.2,
+    // ─── Social ───
+    gaze_contact_ratio: e.facets.assertiveness * 0.3 + a.facets.empathy * 0.25 + es.facets.confidence * 0.25 + e.facets.sociability * 0.2,
+    head_tilt_tendency: a.facets.empathy * 0.35 + o.facets.intellectual_curiosity * 0.3 + a.facets.warmth * 0.2 + (1 - e.facets.assertiveness) * 0.15,
+    postural_openness: a.facets.warmth * 0.3 + a.facets.cooperation * 0.25 + e.facets.sociability * 0.25 + es.facets.confidence * 0.2,
+    smile_frequency: a.facets.warmth * 0.35 + e.facets.enthusiasm * 0.25 + a.facets.empathy * 0.2 + e.facets.sociability * 0.2,
+    // ─── Voice Prosody ───
+    voice_volume: e.facets.assertiveness * 0.35 + e.facets.enthusiasm * 0.3 + es.facets.confidence * 0.2 + (1 - a.facets.cooperation) * 0.15,
+    speaking_rate: e.facets.enthusiasm * 0.3 + e.facets.initiative * 0.25 + (1 - c.facets.attention_to_detail) * 0.25 + o.facets.intellectual_curiosity * 0.2,
+    pitch_variation: e.facets.enthusiasm * 0.3 + o.facets.aesthetic_sensitivity * 0.25 + a.facets.empathy * 0.25 + (1 - es.facets.emotional_regulation) * 0.2,
+    pause_duration: c.facets.attention_to_detail * 0.3 + (1 - e.facets.enthusiasm) * 0.25 + es.facets.emotional_regulation * 0.25 + (1 - e.facets.initiative) * 0.2
+  };
+}
+function computeGazePolicy(bigFive) {
+  const contactRatio = bigFive.extraversion.facets.assertiveness * 0.3 + bigFive.agreeableness.facets.empathy * 0.3 + bigFive.emotional_stability.facets.confidence * 0.25 + bigFive.extraversion.facets.sociability * 0.15;
+  return {
+    contact_ratio: clamp(contactRatio, 0, 1),
+    aversion_style: bigFive.emotional_stability.facets.emotional_regulation >= 0.6 ? "look_away" : "look_down",
+    tracking_mode: "face"
+  };
+}
+function computeProxemics(bigFive) {
+  const closeness = bigFive.extraversion.facets.sociability * 0.35 + bigFive.agreeableness.facets.warmth * 0.3 + bigFive.agreeableness.facets.trust_tendency * 0.2 + bigFive.emotional_stability.facets.confidence * 0.15;
+  let preferred_zone;
+  if (closeness >= 0.75) {
+    preferred_zone = "intimate";
+  } else if (closeness >= 0.5) {
+    preferred_zone = "personal";
+  } else if (closeness >= 0.3) {
+    preferred_zone = "social";
+  } else {
+    preferred_zone = "adaptive";
+  }
+  return {
+    intimate_m: 0.45,
+    personal_m: 1.2,
+    social_m: 3.6,
+    preferred_zone
+  };
+}
+function computeProsody(bigFive) {
+  const e = bigFive.extraversion;
+  const c = bigFive.conscientiousness;
+  const o = bigFive.openness;
+  const es = bigFive.emotional_stability;
+  const rateFactor = e.facets.enthusiasm * 0.3 + e.facets.initiative * 0.25 + (1 - c.facets.attention_to_detail) * 0.25 + o.facets.intellectual_curiosity * 0.2;
+  const pitchVar = e.facets.enthusiasm * 0.3 + o.facets.aesthetic_sensitivity * 0.25 + (1 - es.facets.emotional_regulation) * 0.25 + e.facets.sociability * 0.2;
+  const pauseFactor = c.facets.attention_to_detail * 0.3 + (1 - e.facets.enthusiasm) * 0.25 + es.facets.emotional_regulation * 0.25 + (1 - e.facets.initiative) * 0.2;
+  return {
+    pitch_variation: clamp(pitchVar, 0, 1),
+    speaking_rate_wpm: Math.round(110 + rateFactor * 80),
+    // 110-190 wpm
+    volume_db_offset: Math.round((rateFactor - 0.5) * 6),
+    // -3 to +3 dB
+    pause_tendency: clamp(pauseFactor, 0, 1)
+  };
+}
+function clampToSafety(motion) {
+  const clamped = {};
+  for (const [key, value] of Object.entries(motion)) {
+    clamped[key] = clamp(value, 0, 1);
+  }
+  return clamped;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
 
 // src/core/compiler.ts
 function compile(input2) {
@@ -2259,7 +2582,7 @@ function compile(input2) {
     metadata: {
       personality_hash: hashSpec(spec),
       compiled_at: (/* @__PURE__ */ new Date()).toISOString(),
-      holomime_version: "0.1.0"
+      holomime_version: "1.1.0"
     }
   };
 }
@@ -2269,7 +2592,7 @@ function computeTemperature(bigFive, provider) {
   const e = bigFive.extraversion;
   const raw = o.facets.imagination * 0.25 + o.facets.willingness_to_experiment * 0.2 + (1 - c.facets.orderliness) * 0.2 + (1 - c.facets.attention_to_detail) * 0.15 + e.facets.enthusiasm * 0.1 + o.facets.intellectual_curiosity * 0.1;
   const { temperature: range } = PROVIDER_PARAMS[provider];
-  return clamp(raw * range.max, range.min, range.max);
+  return clamp2(raw * range.max, range.min, range.max);
 }
 function computeTopP(bigFive, provider) {
   const o = bigFive.openness;
@@ -2277,7 +2600,7 @@ function computeTopP(bigFive, provider) {
   const raw = o.facets.imagination * 0.25 + o.facets.willingness_to_experiment * 0.2 + (1 - c.facets.attention_to_detail) * 0.25 + (1 - c.facets.orderliness) * 0.15 + o.facets.aesthetic_sensitivity * 0.15;
   const { top_p: range } = PROVIDER_PARAMS[provider];
   const mapped = 0.5 + raw * 0.5;
-  return clamp(mapped, range.min, range.max);
+  return clamp2(mapped, range.min, range.max);
 }
 function computeMaxTokens(bigFive, provider, surface) {
   const e = bigFive.extraversion;
@@ -2288,9 +2611,9 @@ function computeMaxTokens(bigFive, provider, surface) {
   const surfaceMultiplier = SURFACE_MULTIPLIERS[surface];
   const baseTokens = 256 + factor * (2048 - 256);
   const scaled = Math.round(baseTokens * surfaceMultiplier);
-  return clamp(scaled, 256, range.max);
+  return clamp2(scaled, 256, range.max);
 }
-function clamp(value, min, max) {
+function clamp2(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
 function hashSpec(spec) {
@@ -2372,7 +2695,7 @@ function generateSoul(spec) {
     lines.push("## Growth Areas");
     lines.push("");
     for (const a of spec.growth.areas) {
-      lines.push(`- ${a}`);
+      lines.push(`- ${typeof a === "string" ? a : a.area}`);
     }
     lines.push("");
   }
@@ -2545,6 +2868,58 @@ async function compileCommand(options) {
   }
   const provider = options.provider ?? "anthropic";
   const surface = options.surface ?? "chat";
+  if (surface === "embodied") {
+    const embodiedConfig = await withSpinner(`Compiling ${spec.name} \u2192 ${provider}/embodied...`, async () => {
+      return compileEmbodied(spec, provider);
+    });
+    if (options.output) {
+      const outPath = resolve3(process.cwd(), options.output);
+      writeFileSync3(outPath, JSON.stringify(embodiedConfig, null, 2) + "\n");
+      console.log();
+      printBox(`${figures.tick} Embodied config written to ${options.output}`, "success");
+    } else {
+      printHeader(`${spec.name} \u2192 ${provider}/embodied`);
+      console.log(chalk6.bold("  Model Parameters"));
+      console.log(chalk6.dim("  " + "\u2500".repeat(40)));
+      console.log();
+      console.log(`    temperature: ${chalk6.cyan(embodiedConfig.temperature.toFixed(3))}`);
+      console.log(`    top_p:       ${chalk6.cyan(embodiedConfig.top_p.toFixed(3))}`);
+      console.log(`    max_tokens:  ${chalk6.cyan(embodiedConfig.max_tokens.toString())}`);
+      console.log();
+      console.log(chalk6.bold("  Motion Parameters"));
+      console.log(chalk6.dim("  " + "\u2500".repeat(40)));
+      console.log();
+      const mp = embodiedConfig.motion_parameters;
+      const motionEntries = Object.entries(mp);
+      for (const [key, val] of motionEntries) {
+        const bar3 = "\u2588".repeat(Math.round(val * 20)).padEnd(20, "\u2591");
+        const label = key.replace(/_/g, " ").padEnd(24);
+        console.log(`    ${label} ${chalk6.cyan(bar3)} ${val.toFixed(2)}`);
+      }
+      console.log();
+      console.log(chalk6.bold("  Safety Envelope"));
+      console.log(chalk6.dim("  " + "\u2500".repeat(40)));
+      console.log();
+      const se = embodiedConfig.safety_envelope;
+      console.log(`    max speed:    ${chalk6.yellow(se.max_linear_speed_m_s + " m/s")}`);
+      console.log(`    min proximity: ${chalk6.yellow(se.min_proximity_m + " m")}`);
+      console.log(`    max force:    ${chalk6.yellow(se.max_contact_force_n + " N")}`);
+      console.log(`    e-stop decel: ${chalk6.yellow(se.emergency_stop_decel_m_s2 + " m/s\xB2")}`);
+      console.log();
+      console.log(chalk6.bold("  Expression"));
+      console.log(chalk6.dim("  " + "\u2500".repeat(40)));
+      console.log();
+      console.log(`    modalities:   ${chalk6.green(embodiedConfig.active_modalities.join(", "))}`);
+      console.log(`    gaze contact: ${chalk6.cyan(embodiedConfig.gaze.contact_ratio.toFixed(2))}`);
+      console.log(`    proxemics:    ${chalk6.cyan(embodiedConfig.proxemics.preferred_zone)}`);
+      console.log(`    haptics:      ${chalk6.cyan(embodiedConfig.haptics.touch_permitted ? "permitted" : "not permitted")}`);
+      console.log(`    speak rate:   ${chalk6.cyan(embodiedConfig.prosody.speaking_rate_wpm + " wpm")}`);
+      console.log();
+      printBox(`Embodied config compiled \u2014 use ${chalk6.cyan("--output")} to save JSON`, "info");
+    }
+    console.log();
+    return;
+  }
   const config = await withSpinner(`Compiling ${spec.name} \u2192 ${provider}/${surface}...`, async () => {
     return compile({ spec, provider, surface });
   });
@@ -2652,7 +3027,8 @@ async function validateCommand() {
 import chalk8 from "chalk";
 import figures3 from "figures";
 import { resolve as resolve5 } from "path";
-async function profileCommand() {
+import { writeFileSync as writeFileSync4 } from "fs";
+async function profileCommand(options = {}) {
   const specPath = resolve5(process.cwd(), ".personality.json");
   let raw;
   try {
@@ -2669,6 +3045,16 @@ async function profileCommand() {
     return;
   }
   const spec = parsed.data;
+  if (options.format === "md") {
+    const md = generatePersonalityMarkdown(spec);
+    if (options.output) {
+      writeFileSync4(resolve5(process.cwd(), options.output), md, "utf-8");
+      console.log(chalk8.green(`  Written to ${options.output}`));
+    } else {
+      console.log(md);
+    }
+    return;
+  }
   const bf = spec.big_five;
   const td = spec.therapy_dimensions;
   printHeader(`${spec.name} @${spec.handle}`);
@@ -2779,11 +3165,123 @@ function miniBar(score) {
 function formatEnum2(value) {
   return value.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
+function generatePersonalityMarkdown(spec) {
+  const lines = [];
+  lines.push(`# Agent Personality: ${spec.name}`);
+  lines.push("");
+  if (spec.purpose) {
+    lines.push(`> ${spec.purpose}`);
+    lines.push("");
+  }
+  lines.push(`**Handle**: \`@${spec.handle}\` | **Version**: ${spec.version}`);
+  lines.push("");
+  lines.push("## Personality (Big Five)");
+  lines.push("");
+  lines.push("| Dimension | Score | Style |");
+  lines.push("|-----------|-------|-------|");
+  const dimLabels = {
+    openness: "Openness",
+    conscientiousness: "Conscientiousness",
+    extraversion: "Extraversion",
+    agreeableness: "Agreeableness",
+    emotional_stability: "Emotional Stability"
+  };
+  for (const [key, label] of Object.entries(dimLabels)) {
+    const trait = spec.big_five[key];
+    if (trait) {
+      lines.push(`| ${label} | ${(trait.score * 100).toFixed(0)}% | ${scoreLabel(trait.score)} |`);
+    }
+  }
+  lines.push("");
+  lines.push("### Facets");
+  lines.push("");
+  for (const [key, label] of Object.entries(dimLabels)) {
+    const trait = spec.big_five[key];
+    if (!trait?.facets) continue;
+    const dimDef = DIMENSIONS.find((d) => d.id === key);
+    if (!dimDef) continue;
+    lines.push(`**${label}**`);
+    for (const facetDef of dimDef.facets) {
+      const score = trait.facets[facetDef.id];
+      if (score !== void 0) {
+        lines.push(`- ${facetDef.name}: ${(score * 100).toFixed(0)}%`);
+      }
+    }
+    lines.push("");
+  }
+  const td = spec.therapy_dimensions;
+  lines.push("## Behavioral Dimensions");
+  lines.push("");
+  lines.push(`- **Self-Awareness**: ${(td.self_awareness * 100).toFixed(0)}% (${therapyScoreLabel(td.self_awareness)})`);
+  lines.push(`- **Distress Tolerance**: ${(td.distress_tolerance * 100).toFixed(0)}% (${therapyScoreLabel(td.distress_tolerance)})`);
+  lines.push(`- **Attachment Style**: ${ATTACHMENT_STYLES[td.attachment_style].label}`);
+  lines.push(`- **Learning Orientation**: ${LEARNING_ORIENTATIONS[td.learning_orientation].label}`);
+  lines.push(`- **Boundary Awareness**: ${(td.boundary_awareness * 100).toFixed(0)}% (${therapyScoreLabel(td.boundary_awareness)})`);
+  lines.push(`- **Interpersonal Sensitivity**: ${(td.interpersonal_sensitivity * 100).toFixed(0)}% (${therapyScoreLabel(td.interpersonal_sensitivity)})`);
+  lines.push("");
+  const comm = spec.communication;
+  lines.push("## Communication Style");
+  lines.push("");
+  lines.push(`- **Register**: ${formatEnum2(comm.register)}`);
+  lines.push(`- **Output Format**: ${formatEnum2(comm.output_format)}`);
+  lines.push(`- **Emoji Policy**: ${formatEnum2(comm.emoji_policy)}`);
+  lines.push(`- **Reasoning Transparency**: ${formatEnum2(comm.reasoning_transparency)}`);
+  lines.push(`- **Conflict Approach**: ${formatEnum2(comm.conflict_approach)}`);
+  lines.push(`- **Uncertainty Handling**: ${formatEnum2(comm.uncertainty_handling)}`);
+  lines.push("");
+  if (spec.domain.expertise.length || spec.domain.boundaries.refuses.length) {
+    lines.push("## Domain & Boundaries");
+    lines.push("");
+    if (spec.domain.expertise.length) {
+      lines.push("### Expertise");
+      for (const e of spec.domain.expertise) lines.push(`- ${e}`);
+      lines.push("");
+    }
+    if (spec.domain.boundaries.refuses.length) {
+      lines.push("### Refuses");
+      for (const r of spec.domain.boundaries.refuses) lines.push(`- ${r}`);
+      lines.push("");
+    }
+    if (spec.domain.boundaries.hard_limits.length) {
+      lines.push("### Hard Limits");
+      for (const h of spec.domain.boundaries.hard_limits) lines.push(`- ${h}`);
+      lines.push("");
+    }
+  }
+  if (spec.growth.areas.length || spec.growth.strengths.length || spec.growth.patterns_to_watch.length) {
+    lines.push("## Growth");
+    lines.push("");
+    if (spec.growth.strengths.length) {
+      lines.push("### Strengths");
+      for (const s of spec.growth.strengths) lines.push(`- ${s}`);
+      lines.push("");
+    }
+    if (spec.growth.areas.length) {
+      lines.push("### Areas for Improvement");
+      for (const a of spec.growth.areas) {
+        const text = typeof a === "string" ? a : `${a.area} (${a.severity})`;
+        lines.push(`- ${text}`);
+      }
+      lines.push("");
+    }
+    if (spec.growth.patterns_to_watch.length) {
+      lines.push("### Patterns to Watch");
+      for (const p of spec.growth.patterns_to_watch) lines.push(`- ${p}`);
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by [holomime](https://holomime.dev) \u2014 regenerate with `holomime profile --format md`*");
+  lines.push("*Canonical spec: `.personality.json`*");
+  lines.push("");
+  return lines.join("\n");
+}
 
 // src/commands/diagnose.ts
 import chalk10 from "chalk";
 import figures5 from "figures";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve6 } from "path";
 
 // src/analysis/rules/apology-detector.ts
@@ -3382,6 +3880,229 @@ function isOpenAIAPILog(data) {
   return false;
 }
 
+// src/adapters/anthropic-api.ts
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("");
+}
+function mapRole3(role) {
+  if (role === "user") return "user";
+  if (role === "system") return "system";
+  return "assistant";
+}
+function parseAnthropicAPILog(data) {
+  const items = Array.isArray(data) ? data : [data];
+  const conversations = [];
+  for (const item of items) {
+    const messages = [];
+    let model;
+    if (isRequestResponsePair(item)) {
+      const pair = item;
+      model = pair.request.model ?? pair.response.model;
+      if (pair.request.system) {
+        const systemText = extractTextContent(pair.request.system);
+        if (systemText.trim()) {
+          messages.push({ role: "system", content: systemText });
+        }
+      }
+      for (const msg of pair.request.messages) {
+        const content = extractTextContent(msg.content);
+        if (content.trim()) {
+          messages.push({ role: mapRole3(msg.role), content });
+        }
+      }
+      const responseText = extractTextContent(pair.response.content);
+      if (responseText.trim()) {
+        messages.push({ role: "assistant", content: responseText });
+      }
+    } else {
+      const resp = item;
+      model = resp.model;
+      const text = extractTextContent(resp.content);
+      if (text.trim()) {
+        messages.push({ role: "assistant", content: text });
+      }
+    }
+    if (messages.length > 0) {
+      conversations.push({
+        id: item.id ?? item.response?.id,
+        messages,
+        metadata: {
+          source: "anthropic-api",
+          ...model && { model }
+        }
+      });
+    }
+  }
+  return conversations;
+}
+function isRequestResponsePair(item) {
+  return typeof item === "object" && item !== null && "request" in item && "response" in item && typeof item.request === "object" && typeof item.response === "object";
+}
+function isAnthropicAPILog(data) {
+  if (isAnthropicResponse(data)) return true;
+  if (isRequestResponsePair(data)) return true;
+  if (Array.isArray(data) && data.length > 0) {
+    return isAnthropicResponse(data[0]) || isRequestResponsePair(data[0]);
+  }
+  return false;
+}
+function isAnthropicResponse(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const obj = data;
+  return obj.type === "message" && Array.isArray(obj.content);
+}
+
+// src/adapters/otel-genai.ts
+function getAttr(attrs, key) {
+  if (!attrs) return void 0;
+  const attr = attrs.find((a) => a.key === key);
+  if (!attr) return void 0;
+  return attr.value.stringValue ?? (attr.value.intValue != null ? String(attr.value.intValue) : void 0);
+}
+function hasGenAIAttrs(attrs) {
+  if (!attrs) return false;
+  return attrs.some((a) => a.key.startsWith("gen_ai."));
+}
+function mapRole4(role) {
+  if (role === "user") return "user";
+  if (role === "system") return "system";
+  return "assistant";
+}
+function nanoToISO(nano) {
+  if (!nano) return void 0;
+  const ms = Number(BigInt(nano) / BigInt(1e6));
+  return new Date(ms).toISOString();
+}
+function parseOTelGenAIExport(data) {
+  const traceMap = /* @__PURE__ */ new Map();
+  for (const rs of data.resourceSpans) {
+    for (const ss of rs.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        if (!hasGenAIAttrs(span.attributes)) continue;
+        const traceId = span.traceId;
+        if (!traceMap.has(traceId)) {
+          traceMap.set(traceId, { messages: [] });
+        }
+        const trace = traceMap.get(traceId);
+        const system = getAttr(span.attributes, "gen_ai.system");
+        const model = getAttr(span.attributes, "gen_ai.request.model");
+        if (system) trace.system = system;
+        if (model) trace.model = model;
+        const timestamp = nanoToISO(span.startTimeUnixNano);
+        const messagesAttr = span.attributes?.find((a) => a.key === "gen_ai.request.messages");
+        if (messagesAttr?.value.stringValue) {
+          try {
+            const parsed = JSON.parse(messagesAttr.value.stringValue);
+            if (Array.isArray(parsed)) {
+              for (const m of parsed) {
+                if (m.role && m.content) {
+                  trace.messages.push({
+                    role: mapRole4(m.role),
+                    content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+                    ...timestamp && { timestamp }
+                  });
+                }
+              }
+              continue;
+            }
+          } catch {
+          }
+        }
+        const promptContent = getAttr(span.attributes, "gen_ai.prompt.0.content");
+        const completionContent = getAttr(span.attributes, "gen_ai.completion.0.content");
+        if (promptContent) {
+          trace.messages.push({
+            role: "user",
+            content: promptContent,
+            ...timestamp && { timestamp }
+          });
+        }
+        if (completionContent) {
+          trace.messages.push({
+            role: "assistant",
+            content: completionContent,
+            ...timestamp && { timestamp }
+          });
+        }
+      }
+    }
+  }
+  const conversations = [];
+  for (const [traceId, trace] of traceMap) {
+    if (trace.messages.length === 0) continue;
+    conversations.push({
+      id: traceId,
+      messages: trace.messages,
+      metadata: {
+        source: "otel",
+        ...trace.system && { system: trace.system },
+        ...trace.model && { model: trace.model }
+      }
+    });
+  }
+  return conversations;
+}
+function isOTelGenAIExport(data) {
+  if (typeof data !== "object" || data === null) return false;
+  if (!("resourceSpans" in data) || !Array.isArray(data.resourceSpans)) return false;
+  const rs = data.resourceSpans;
+  for (const r of rs) {
+    for (const ss of r.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        if (hasGenAIAttrs(span.attributes)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/adapters/jsonl.ts
+function mapRole5(role) {
+  if (role === "user") return "user";
+  if (role === "system") return "system";
+  return "assistant";
+}
+function parseJSONLLog(raw) {
+  const lines = raw.split("\n").filter((l) => l.trim() !== "");
+  const convMap = /* @__PURE__ */ new Map();
+  const defaultKey = "__default__";
+  for (const line of lines) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) continue;
+    if (typeof parsed.role !== "string" || typeof parsed.content !== "string") continue;
+    const convId = typeof parsed.conversation_id === "string" ? parsed.conversation_id : defaultKey;
+    if (!convMap.has(convId)) {
+      convMap.set(convId, []);
+    }
+    const message = {
+      role: mapRole5(parsed.role),
+      content: parsed.content
+    };
+    if (typeof parsed.timestamp === "string") {
+      message.timestamp = parsed.timestamp;
+    } else if (typeof parsed.timestamp === "number") {
+      message.timestamp = new Date(parsed.timestamp * 1e3).toISOString();
+    }
+    convMap.get(convId).push(message);
+  }
+  const conversations = [];
+  for (const [key, messages] of convMap) {
+    if (messages.length === 0) continue;
+    conversations.push({
+      ...key !== defaultKey && { id: key },
+      messages,
+      metadata: { source: "jsonl" }
+    });
+  }
+  return conversations;
+}
+
 // src/adapters/log-adapter.ts
 function parseConversationLog(raw, format = "auto") {
   if (format === "holomime") {
@@ -3397,6 +4118,16 @@ function parseConversationLog(raw, format = "auto") {
   if (format === "openai-api") {
     return parseOpenAIAPILog(raw);
   }
+  if (format === "anthropic-api") {
+    return parseAnthropicAPILog(raw);
+  }
+  if (format === "otel") {
+    return parseOTelGenAIExport(raw);
+  }
+  if (format === "jsonl") {
+    if (typeof raw !== "string") throw new Error("JSONL format expects a raw string (not parsed JSON)");
+    return parseJSONLLog(raw);
+  }
   const holomimeResult = conversationLogSchema.safeParse(raw);
   if (holomimeResult.success) {
     const log = holomimeResult.data;
@@ -3408,11 +4139,17 @@ function parseConversationLog(raw, format = "auto") {
   if (isClaudeExport(raw)) {
     return parseClaudeExport(raw);
   }
+  if (isAnthropicAPILog(raw)) {
+    return parseAnthropicAPILog(raw);
+  }
   if (isOpenAIAPILog(raw)) {
     return parseOpenAIAPILog(raw);
   }
+  if (isOTelGenAIExport(raw)) {
+    return parseOTelGenAIExport(raw);
+  }
   throw new Error(
-    "Unrecognized log format. Supported: holomime, chatgpt, claude, openai-api. Use --format to specify explicitly."
+    "Unrecognized log format. Supported: holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl. Use --format to specify explicitly."
   );
 }
 function parseHolomime(raw) {
@@ -3429,7 +4166,7 @@ async function diagnoseCommand(options) {
   const logPath = resolve6(process.cwd(), options.log);
   let raw;
   try {
-    raw = readFileSync4(logPath, "utf-8");
+    raw = readFileSync3(logPath, "utf-8");
   } catch {
     console.error(chalk10.red(`  Could not read log file: ${options.log}`));
     process.exit(1);
@@ -3513,7 +4250,7 @@ async function diagnoseCommand(options) {
 // src/commands/assess.ts
 import chalk11 from "chalk";
 import figures6 from "figures";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import { resolve as resolve7, join as join2 } from "path";
 
 // src/analysis/trait-scorer.ts
@@ -3538,7 +4275,7 @@ function scoreOpenness(msgs) {
   const allWords = msgs.map((m) => m.content.toLowerCase().split(/\s+/)).flat();
   const uniqueRatio = new Set(allWords).size / Math.max(allWords.length, 1);
   score += (uniqueRatio - 0.3) * 0.5;
-  return clamp2(score);
+  return clamp3(score);
 }
 function scoreConscientiousness(msgs) {
   let score = 0.5;
@@ -3551,7 +4288,7 @@ function scoreConscientiousness(msgs) {
   const variance = lengths.reduce((s, l) => s + (l - mean) ** 2, 0) / lengths.length;
   const cv = Math.sqrt(variance) / Math.max(mean, 1);
   score -= cv * 0.1;
-  return clamp2(score);
+  return clamp3(score);
 }
 function scoreExtraversion(msgs) {
   let score = 0.5;
@@ -3565,7 +4302,7 @@ function scoreExtraversion(msgs) {
   const proactivePatterns = /\b(you could|i suggest|let('s| us)|next step|how about|shall we)\b/i;
   const proactiveCount = msgs.filter((m) => proactivePatterns.test(m.content)).length;
   score += proactiveCount / msgs.length * 0.15;
-  return clamp2(score);
+  return clamp3(score);
 }
 function scoreAgreeableness(msgs) {
   let score = 0.5;
@@ -3578,7 +4315,7 @@ function scoreAgreeableness(msgs) {
   const empathyPatterns = /\b(i understand (how|that|your)|that must (be|feel)|i can see why|i appreciate)\b/i;
   const empathyCount = msgs.filter((m) => empathyPatterns.test(m.content)).length;
   score += empathyCount / msgs.length * 0.15;
-  return clamp2(score);
+  return clamp3(score);
 }
 function scoreEmotionalStability(msgs) {
   let score = 0.6;
@@ -3591,9 +4328,9 @@ function scoreEmotionalStability(msgs) {
   const confidencePatterns = /\b(certainly|definitely|clearly|without doubt|here's what|the answer is)\b/i;
   const confidenceCount = msgs.filter((m) => confidencePatterns.test(m.content)).length;
   score += confidenceCount / msgs.length * 0.15;
-  return clamp2(score);
+  return clamp3(score);
 }
-function clamp2(n) {
+function clamp3(n) {
   return Math.min(1, Math.max(0, Math.round(n * 100) / 100));
 }
 
@@ -3633,6 +4370,31 @@ function generatePrescriptions(alignments, patterns) {
   prescriptions.sort((a, b) => order[a.priority] - order[b.priority]);
   return prescriptions;
 }
+function prescribeDPOPairs(patterns, corpus, limit = 20) {
+  const patternIds = new Set(patterns.map((p) => p.id));
+  const dpoPairs = [];
+  for (const event of corpus) {
+    if (event.event_type !== "dpo_pair") continue;
+    const data = event.data;
+    const eventPattern = data.pattern;
+    if (eventPattern && patternIds.has(eventPattern)) {
+      dpoPairs.push({
+        prompt: data.prompt ?? "",
+        chosen: data.chosen ?? "",
+        rejected: data.rejected ?? "",
+        metadata: {
+          agent: event.agent,
+          session_date: event.timestamp,
+          phase: data.phase ?? "challenge",
+          pattern: eventPattern,
+          source: "therapy_transcript"
+        }
+      });
+    }
+    if (dpoPairs.length >= limit) break;
+  }
+  return dpoPairs;
+}
 
 // src/commands/assess.ts
 async function assessCommand(options) {
@@ -3648,7 +4410,7 @@ async function assessCommand(options) {
   const logPath = resolve7(process.cwd(), options.log);
   let conversations;
   try {
-    const raw = readFileSync5(logPath, "utf-8");
+    const raw = readFileSync4(logPath, "utf-8");
     conversations = parseConversationLog(JSON.parse(raw), options.format ?? "auto");
   } catch (err) {
     console.error(chalk11.red(`  ${err instanceof Error ? err.message : "Could not read/parse log file."}`));
@@ -3754,7 +4516,7 @@ async function assessCommand(options) {
   };
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filepath = join2(assessDir, `${date}.json`);
-  writeFileSync4(filepath, JSON.stringify(snapshot, null, 2));
+  writeFileSync5(filepath, JSON.stringify(snapshot, null, 2));
   console.log(chalk11.dim(`  Assessment saved: ${filepath}`));
   if (warnings.length > 0) {
     showSoftUpsell("assess");
@@ -3766,7 +4528,7 @@ async function assessCommand(options) {
 import chalk14 from "chalk";
 import figures7 from "figures";
 import { createInterface } from "readline";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
 import { resolve as resolve9 } from "path";
 
 // src/analysis/pre-session.ts
@@ -3855,8 +4617,8 @@ function runPreSessionDiagnosis(messages, spec) {
 }
 
 // src/analysis/session-runner.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
-import { resolve as resolve8, join as join3 } from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { resolve as resolve8, join as join4 } from "path";
 
 // src/analysis/therapy-protocol.ts
 var THERAPY_PHASES = {
@@ -4095,19 +4857,62 @@ ${JSON.stringify(spec.growth ?? {}, null, 2)}
 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 patientSystem = buildPatientSystemPrompt(spec);
-  const agentName = spec.name ?? "Agent";
-  const cb = options?.callbacks;
-  const therapistHistory = [
-    { role: "system", content: therapistSystem }
-  ];
-  const patientHistory = [
-    { role: "system", content: patientSystem }
-  ];
-  const interactive = options?.interactive ?? false;
+// src/analysis/behavioral-data.ts
+import { appendFileSync, readFileSync as readFileSync5, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { createHash } from "crypto";
+var HOLOMIME_DIR = ".holomime";
+var CORPUS_FILENAME = "behavioral-corpus.jsonl";
+function getCorpusPath(basePath) {
+  const dir = basePath ?? join3(process.cwd(), HOLOMIME_DIR);
+  return join3(dir, CORPUS_FILENAME);
+}
+function ensureDir(filePath) {
+  const dir = dirname2(filePath);
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+}
+function hashSpec2(spec) {
+  const json = JSON.stringify(spec, Object.keys(spec).sort());
+  return createHash("sha256").update(json).digest("hex").slice(0, 16);
+}
+function emitBehavioralEvent(event, corpusDir) {
+  const fullEvent = {
+    ...event,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const corpusPath = corpusDir ? join3(corpusDir, CORPUS_FILENAME) : getCorpusPath();
+  ensureDir(corpusPath);
+  appendFileSync(corpusPath, JSON.stringify(fullEvent) + "\n", "utf-8");
+}
+function loadCorpus(corpusPath) {
+  const path = corpusPath ?? getCorpusPath();
+  if (!existsSync4(path)) return [];
+  const lines = readFileSync5(path, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
+}
+
+// src/analysis/session-runner.ts
+async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
+  const therapistSystem = buildTherapistSystemPrompt(spec, diagnosis);
+  const patientSystem = buildPatientSystemPrompt(spec);
+  const agentName = spec.name ?? "Agent";
+  const cb = options?.callbacks;
+  const therapistHistory = [
+    { role: "system", content: therapistSystem }
+  ];
+  const patientHistory = [
+    { role: "system", content: patientSystem }
+  ];
+  const interactive = options?.interactive ?? false;
   let supervisorInterventions = 0;
   const transcript = {
     agent: agentName,
@@ -4186,6 +4991,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) {
@@ -4216,7 +5036,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")) {
@@ -4276,18 +5096,103 @@ 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 = resolve8(process.cwd(), ".holomime", "sessions");
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  if (!existsSync5(dir)) {
+    mkdirSync4(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 = join3(dir, filename);
-  writeFileSync5(filepath, JSON.stringify(transcript, null, 2));
+  const filepath = join4(dir, filename);
+  writeFileSync6(filepath, JSON.stringify(transcript, null, 2));
   return filepath;
 }
 
@@ -4740,19 +5645,19 @@ async function runLiveSession(spec, diagnosis, provider, maxTurns, apply, intera
       onSupervisorPrompt: interactive ? async (phase, turn) => {
         if (skipInteractive) return null;
         const rl = createInterface({ input: process.stdin, output: process.stdout });
-        return new Promise((resolve30) => {
+        return new Promise((resolve34) => {
           rl.question(chalk14.magenta(`
   [Supervisor] `) + chalk14.dim(`(phase: ${phase}, turn ${turn}) `) + chalk14.magenta(`> `), (answer) => {
             rl.close();
             const trimmed = answer.trim();
-            if (trimmed === "") return resolve30(null);
+            if (trimmed === "") return resolve34(null);
             if (trimmed.toLowerCase() === "skip") {
               skipInteractive = true;
               console.log(chalk14.dim("  Supervisor mode disabled for remaining session."));
-              return resolve30(null);
+              return resolve34(null);
             }
             console.log(chalk14.dim(`  Directive injected into session context.`));
-            return resolve30(trimmed);
+            return resolve34(trimmed);
           });
         });
       } : void 0
@@ -4776,9 +5681,9 @@ Exchanges: ${Math.floor(transcript.turns.filter((t) => t.speaker !== "supervisor
     console.log();
     if (apply) {
       const specPath = resolve9(process.cwd(), ".personality.json");
-      const { changed, changes } = applyRecommendations(spec, diagnosis);
+      const { changed, changes } = await applyRecommendations(spec, diagnosis, transcript, provider);
       if (changed) {
-        writeFileSync6(specPath, JSON.stringify(spec, null, 2) + "\n");
+        writeFileSync7(specPath, JSON.stringify(spec, null, 2) + "\n");
         console.log();
         printBox(`${figures7.tick} Applied session recommendations to .personality.json`, "success", "Applied");
         console.log();
@@ -4885,18 +5790,18 @@ function runSimulatedSession(spec, diagnosis) {
 // src/commands/growth.ts
 import chalk15 from "chalk";
 import figures8 from "figures";
-import { readdirSync, existsSync as existsSync6 } from "fs";
-import { resolve as resolve11, join as join5 } from "path";
+import { readdirSync, readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
+import { resolve as resolve11, join as join6 } from "path";
 
 // src/analysis/evolution-history.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
 import { resolve as resolve10 } from "path";
 function getEvolutionPath() {
   return resolve10(process.cwd(), ".holomime", "evolution.json");
 }
 function loadEvolution(agentName) {
   const filepath = getEvolutionPath();
-  if (!existsSync5(filepath)) return null;
+  if (!existsSync6(filepath)) return null;
   try {
     const raw = readFileSync7(filepath, "utf-8");
     return JSON.parse(raw);
@@ -4907,8 +5812,8 @@ function loadEvolution(agentName) {
 function appendEvolution(entry, agentName) {
   const filepath = getEvolutionPath();
   const dir = resolve10(process.cwd(), ".holomime");
-  if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  if (!existsSync6(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   let history = loadEvolution(agentName);
   if (!history) {
@@ -4925,7 +5830,7 @@ function appendEvolution(entry, agentName) {
   history.totalSessions = history.entries.length;
   history.totalDPOPairs = history.entries.reduce((sum, e) => sum + e.dpoPairsExtracted, 0);
   history.lastSession = entry.timestamp;
-  writeFileSync7(filepath, JSON.stringify(history, null, 2) + "\n");
+  writeFileSync8(filepath, JSON.stringify(history, null, 2) + "\n");
 }
 function getEvolutionSummary(history) {
   const entries = history.entries;
@@ -4975,7 +5880,7 @@ async function growthCommand(options) {
   }
   const historyDir = resolve11(process.cwd(), options.history ?? ".holomime/assessments");
   printHeader(`Growth Report \u2014 ${spec.name ?? "Unknown"}`);
-  if (!existsSync6(historyDir)) {
+  if (!existsSync7(historyDir)) {
     console.log(chalk15.dim("  No assessment history found."));
     console.log(chalk15.dim(`  Run assessments first: holomime assess --personality ${options.personality} --log <conversation.json>`));
     console.log();
@@ -4996,7 +5901,7 @@ async function growthCommand(options) {
   const snapshots = [];
   for (const file of files) {
     try {
-      const data = JSON.parse(readFileSync(join5(historyDir, file), "utf-8"));
+      const data = JSON.parse(readFileSync8(join6(historyDir, file), "utf-8"));
       snapshots.push(data);
     } catch {
     }
@@ -5190,7 +6095,7 @@ async function browseCommand(options) {
 // src/commands/pull.ts
 import chalk17 from "chalk";
 import figures9 from "figures";
-import { writeFileSync as writeFileSync8, existsSync as existsSync7 } from "fs";
+import { writeFileSync as writeFileSync9, existsSync as existsSync8 } from "fs";
 import { resolve as resolve12 } from "path";
 import { select as select2 } from "@inquirer/prompts";
 async function pullCommand(handle, options) {
@@ -5228,7 +6133,7 @@ async function pullCommand(handle, options) {
     return;
   }
   const outputPath = resolve12(process.cwd(), options.output ?? ".personality.json");
-  if (existsSync7(outputPath)) {
+  if (existsSync8(outputPath)) {
     const overwrite = await select2({
       message: `.personality.json already exists. Overwrite?`,
       choices: [
@@ -5241,7 +6146,7 @@ async function pullCommand(handle, options) {
       return;
     }
   }
-  writeFileSync8(outputPath, JSON.stringify(result.data, null, 2) + "\n");
+  writeFileSync9(outputPath, JSON.stringify(result.data, null, 2) + "\n");
   console.log();
   printBox(`${figures9.tick} Pulled ${entry.name} (@${entry.handle}) to ${outputPath}`, "success");
   console.log();
@@ -5252,14 +6157,14 @@ async function pullCommand(handle, options) {
 // src/commands/publish.ts
 import chalk18 from "chalk";
 import figures10 from "figures";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { resolve as resolve13 } from "path";
 async function publishCommand(options) {
   const specPath = resolve13(process.cwd(), options.personality ?? ".personality.json");
   printHeader("Publish Personality");
   let raw;
   try {
-    raw = readFileSync8(specPath, "utf-8");
+    raw = readFileSync9(specPath, "utf-8");
   } catch {
     console.error(chalk18.red(`  Could not read: ${specPath}`));
     console.log(chalk18.dim(`  Run ${chalk18.cyan("holomime init")} to create a personality first.`));
@@ -5329,11 +6234,11 @@ async function publishCommand(options) {
 // src/commands/autopilot.ts
 import chalk19 from "chalk";
 import figures11 from "figures";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { resolve as resolve14 } from "path";
 
 // src/analysis/autopilot-core.ts
-import { writeFileSync as writeFileSync9 } from "fs";
+import { writeFileSync as writeFileSync10 } from "fs";
 var SEVERITY_ORDER = ["routine", "targeted", "intervention"];
 function severityMeetsThreshold(severity, threshold) {
   const severityIdx = SEVERITY_ORDER.indexOf(severity);
@@ -5368,9 +6273,9 @@ 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) {
-    writeFileSync9(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
+    writeFileSync10(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
   }
   saveTranscript(transcript, spec.name ?? "Agent");
   return {
@@ -5399,7 +6304,7 @@ async function autopilotCommand(options) {
   const logPath = resolve14(process.cwd(), options.log);
   let messages;
   try {
-    const raw = JSON.parse(readFileSync9(logPath, "utf-8"));
+    const raw = JSON.parse(readFileSync10(logPath, "utf-8"));
     const conversations = parseConversationLog(raw, options.format ?? "auto");
     messages = conversations.flatMap((c) => c.messages);
   } catch (err) {
@@ -5540,12 +6445,12 @@ async function autopilotCommand(options) {
 // src/commands/export.ts
 import chalk20 from "chalk";
 import figures12 from "figures";
-import { writeFileSync as writeFileSync10 } from "fs";
+import { writeFileSync as writeFileSync11 } from "fs";
 import { resolve as resolve15 } from "path";
 
 // src/analysis/training-export.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
-import { join as join6 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { join as join7 } from "path";
 function extractDPOPairs(transcript) {
   const pairs = [];
   const turns = transcript.turns;
@@ -5651,7 +6556,7 @@ function loadTranscripts(sessionsDir) {
   try {
     const files = readdirSync2(sessionsDir).filter((f) => f.endsWith(".json")).sort();
     return files.map((f) => {
-      const raw = readFileSync10(join6(sessionsDir, f), "utf-8");
+      const raw = readFileSync11(join7(sessionsDir, f), "utf-8");
       return JSON.parse(raw);
     });
   } catch {
@@ -5742,6 +6647,62 @@ function extractInstructionFromTherapist(content) {
   );
   return actionable?.trim() ?? sentences[0]?.trim() ?? content;
 }
+async function extractDPOPairsWithLLM(transcript, provider) {
+  const regexPairs = extractDPOPairs(transcript);
+  const condensed = transcript.turns.filter((t) => t.speaker !== "supervisor").map((t) => `[${t.phase}] ${t.speaker}: ${t.content}`).join("\n");
+  if (condensed.length < 100) return regexPairs;
+  try {
+    const response = await provider.chat([
+      {
+        role: "system",
+        content: `You extract DPO (Direct Preference Optimization) training pairs from therapy transcripts.
+
+A DPO pair consists of:
+- "prompt": The situation or question the agent was responding to
+- "rejected": The agent's problematic/drifted response (what NOT to do)
+- "chosen": The improved response (what TO do)
+
+Look for:
+1. Patient demonstrates a bad behavior \u2192 therapist corrects \u2192 patient shows improvement
+2. Therapist explicitly contrasts old vs new approach
+3. Patient practices a new skill that differs from earlier behavior
+4. Any before/after behavioral contrast
+
+Return ONLY a JSON array of objects with prompt, chosen, rejected fields.
+Return [] if no clear pairs exist. Max 10 pairs.`
+      },
+      {
+        role: "user",
+        content: condensed
+      }
+    ]);
+    const jsonMatch = response.match(/\[[\s\S]*?\]/);
+    if (!jsonMatch) return regexPairs;
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (!Array.isArray(parsed)) return regexPairs;
+    const llmPairs = parsed.filter(
+      (p) => typeof p.prompt === "string" && p.prompt.length > 0 && typeof p.chosen === "string" && p.chosen.length > 0 && typeof p.rejected === "string" && p.rejected.length > 0 && p.chosen !== p.rejected
+    ).map((p) => ({
+      prompt: p.prompt,
+      chosen: p.chosen,
+      rejected: p.rejected,
+      metadata: {
+        agent: transcript.agent,
+        session_date: transcript.timestamp.split("T")[0],
+        phase: "integration",
+        pattern: "llm_extracted",
+        source: "therapy_transcript"
+      }
+    }));
+    const existingRejected = new Set(regexPairs.map((p) => p.rejected.toLowerCase().slice(0, 80)));
+    const uniqueLLMPairs = llmPairs.filter(
+      (p) => !existingRejected.has(p.rejected.toLowerCase().slice(0, 80))
+    );
+    return [...regexPairs, ...uniqueLLMPairs];
+  } catch {
+    return regexPairs;
+  }
+}
 
 // src/analysis/export-huggingface.ts
 function convertToHFFormat(data) {
@@ -5887,16 +6848,16 @@ Run ${chalk20.cyan("holomime session")} first to generate session transcripts.`,
   const outputPath = options.output ?? `.holomime/exports/${format}-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${isJsonl ? "jsonl" : "json"}`;
   const fullPath = resolve15(process.cwd(), outputPath);
   const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-  const { mkdirSync: mkdirSync15 } = await import("fs");
-  mkdirSync15(dir, { recursive: true });
+  const { mkdirSync: mkdirSync16 } = await import("fs");
+  mkdirSync16(dir, { recursive: true });
   if (format === "huggingface" || format === "openai") {
     const jsonl = convertToHFFormat(result);
-    writeFileSync10(fullPath, jsonl);
+    writeFileSync11(fullPath, jsonl);
   } else if (format === "jsonl") {
     const lines = result.examples.map((ex) => JSON.stringify(ex)).join("\n");
-    writeFileSync10(fullPath, lines + "\n");
+    writeFileSync11(fullPath, lines + "\n");
   } else {
-    writeFileSync10(fullPath, JSON.stringify(result, null, 2) + "\n");
+    writeFileSync11(fullPath, JSON.stringify(result, null, 2) + "\n");
   }
   console.log(`  ${chalk20.green(figures12.tick)} Written to ${chalk20.cyan(outputPath)}`);
   console.log();
@@ -5981,8 +6942,8 @@ This is the closed-loop behavioral alignment system.`,
 // src/commands/train.ts
 import chalk21 from "chalk";
 import figures13 from "figures";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync13, mkdirSync as mkdirSync7, readdirSync as readdirSync3, existsSync as existsSync9 } from "fs";
-import { resolve as resolve19, join as join9 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync14, mkdirSync as mkdirSync8, readdirSync as readdirSync3, existsSync as existsSync10 } from "fs";
+import { resolve as resolve19, join as join10 } from "path";
 
 // src/analysis/train-provider.ts
 function inferMethod(data, preferred) {
@@ -5991,7 +6952,7 @@ function inferMethod(data, preferred) {
 }
 
 // src/analysis/train-openai.ts
-import { readFileSync as readFileSync11, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync9 } from "fs";
 import { resolve as resolve16 } from "path";
 var OPENAI_API = "https://api.openai.com/v1";
 var POLL_INTERVAL_MS = 1e4;
@@ -6091,7 +7052,7 @@ async function getJobEvents(apiKey, jobId, limit = 5) {
   return data.data ?? [];
 }
 function sleep(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve34) => setTimeout(resolve34, ms));
 }
 var OpenAITrainProvider = class {
   name = "openai";
@@ -6102,9 +7063,9 @@ var OpenAITrainProvider = class {
     let systemPrompt;
     if (options.personalityPath) {
       const fullPath = resolve16(process.cwd(), options.personalityPath);
-      if (existsSync8(fullPath)) {
+      if (existsSync9(fullPath)) {
         try {
-          const spec = JSON.parse(readFileSync11(fullPath, "utf-8"));
+          const spec = JSON.parse(readFileSync12(fullPath, "utf-8"));
           const name = spec.name ?? "Agent";
           const purpose = spec.purpose ?? "";
           const parts = [`You are ${name}.`];
@@ -6193,8 +7154,8 @@ var OpenAITrainProvider = class {
 
 // src/analysis/train-huggingface.ts
 import { spawn } from "child_process";
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync5 } from "fs";
-import { resolve as resolve17, join as join7 } from "path";
+import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve17, join as join8 } from "path";
 import { createInterface as createInterface2 } from "readline";
 async function checkPythonDeps() {
   const pythonCandidates = ["python3", "python"];
@@ -6224,9 +7185,9 @@ async function checkPythonDeps() {
 }
 function writeHFTrainingFile(data) {
   const tmpDir = resolve17(process.cwd(), ".holomime/tmp");
-  mkdirSync5(tmpDir, { recursive: true });
-  const filePath = join7(tmpDir, `hf-train-${Date.now()}.json`);
-  writeFileSync11(filePath, JSON.stringify(data, null, 2));
+  mkdirSync6(tmpDir, { recursive: true });
+  const filePath = join8(tmpDir, `hf-train-${Date.now()}.json`);
+  writeFileSync12(filePath, JSON.stringify(data, null, 2));
   return filePath;
 }
 var HuggingFaceTrainProvider = class {
@@ -6345,8 +7306,8 @@ var HuggingFaceTrainProvider = class {
 
 // src/analysis/train-eval.ts
 import { spawn as spawn2 } from "child_process";
-import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve18, join as join8 } from "path";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve18, join as join9 } from "path";
 import { createInterface as createInterface3 } from "readline";
 
 // src/analysis/diagnose-core.ts
@@ -6362,16 +7323,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/outcome-eval.ts
@@ -6594,9 +7570,9 @@ async function runHFAutoEval(baseModel, fineTunedModel, agentName, data, onProgr
     return evaluateOutcome(agentName, [], []);
   }
   const tmpDir = resolve18(process.cwd(), ".holomime/tmp");
-  mkdirSync6(tmpDir, { recursive: true });
-  const promptsPath = join8(tmpDir, `eval-prompts-${Date.now()}.json`);
-  writeFileSync12(promptsPath, JSON.stringify(prompts));
+  mkdirSync7(tmpDir, { recursive: true });
+  const promptsPath = join9(tmpDir, `eval-prompts-${Date.now()}.json`);
+  writeFileSync13(promptsPath, JSON.stringify(prompts));
   const scriptPath = resolve18(
     new URL(".", import.meta.url).pathname,
     "../../scripts/eval_hf.py"
@@ -6662,13 +7638,13 @@ async function findPython() {
 function findLatestExport(exportsDir) {
   try {
     const files = readdirSync3(exportsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort().reverse();
-    return files[0] ? join9(exportsDir, files[0]) : null;
+    return files[0] ? join10(exportsDir, files[0]) : null;
   } catch {
     return null;
   }
 }
 function loadTrainingData(dataPath) {
-  const raw = readFileSync12(dataPath, "utf-8");
+  const raw = readFileSync13(dataPath, "utf-8");
   const data = JSON.parse(raw);
   if (!data.format || !data.examples || !Array.isArray(data.examples)) {
     throw new Error("Invalid training data \u2014 expected holomime export format");
@@ -6677,7 +7653,7 @@ function loadTrainingData(dataPath) {
 }
 function getAgentName(personalityPath) {
   try {
-    const spec = JSON.parse(readFileSync12(personalityPath, "utf-8"));
+    const spec = JSON.parse(readFileSync13(personalityPath, "utf-8"));
     return spec.name ?? "Agent";
   } catch {
     return "Agent";
@@ -6685,19 +7661,19 @@ function getAgentName(personalityPath) {
 }
 function deployModel(result, personalityPath) {
   const trainingDir = resolve19(process.cwd(), ".holomime/training");
-  mkdirSync7(trainingDir, { recursive: true });
+  mkdirSync8(trainingDir, { recursive: true });
   const record = {
     ...result,
     deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
     personalityPath
   };
-  writeFileSync13(
-    join9(trainingDir, "latest.json"),
+  writeFileSync14(
+    join10(trainingDir, "latest.json"),
     JSON.stringify(record, null, 2) + "\n"
   );
   const fullPath = resolve19(process.cwd(), personalityPath);
-  if (existsSync9(fullPath)) {
-    const spec = JSON.parse(readFileSync12(fullPath, "utf-8"));
+  if (existsSync10(fullPath)) {
+    const spec = JSON.parse(readFileSync13(fullPath, "utf-8"));
     spec.training = {
       ...spec.training ?? {},
       fine_tuned_model: result.modelId,
@@ -6706,7 +7682,7 @@ function deployModel(result, personalityPath) {
       examples: result.examples,
       trained_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync13(fullPath, JSON.stringify(spec, null, 2) + "\n");
+    writeFileSync14(fullPath, JSON.stringify(spec, null, 2) + "\n");
   }
 }
 async function trainCommand(options) {
@@ -6730,7 +7706,7 @@ async function trainCommand(options) {
     }
   }
   const dataPath = options.data ? resolve19(process.cwd(), options.data) : findLatestExport(resolve19(process.cwd(), ".holomime/exports"));
-  if (!dataPath || !existsSync9(dataPath)) {
+  if (!dataPath || !existsSync10(dataPath)) {
     console.log();
     printBox(
       `No training data found.
@@ -6948,14 +7924,14 @@ Fine-tuned model: ${chalk21.cyan(result.modelId)}`,
 // src/commands/eval.ts
 import chalk22 from "chalk";
 import figures14 from "figures";
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { resolve as resolve20 } from "path";
 async function evalCommand(options) {
   printHeader("Outcome Evaluation");
   const beforePath = resolve20(process.cwd(), options.before);
   let beforeMessages;
   try {
-    const raw = JSON.parse(readFileSync13(beforePath, "utf-8"));
+    const raw = JSON.parse(readFileSync14(beforePath, "utf-8"));
     const conversations = parseConversationLog(raw, options.format ?? "auto");
     beforeMessages = conversations.flatMap((c) => c.messages);
   } catch (err) {
@@ -6966,7 +7942,7 @@ async function evalCommand(options) {
   const afterPath = resolve20(process.cwd(), options.after);
   let afterMessages;
   try {
-    const raw = JSON.parse(readFileSync13(afterPath, "utf-8"));
+    const raw = JSON.parse(readFileSync14(afterPath, "utf-8"));
     const conversations = parseConversationLog(raw, options.format ?? "auto");
     afterMessages = conversations.flatMap((c) => c.messages);
   } catch (err) {
@@ -6977,7 +7953,7 @@ async function evalCommand(options) {
   let agentName = "Agent";
   if (options.personality) {
     try {
-      const spec = JSON.parse(readFileSync13(resolve20(process.cwd(), options.personality), "utf-8"));
+      const spec = JSON.parse(readFileSync14(resolve20(process.cwd(), options.personality), "utf-8"));
       agentName = spec.name ?? "Agent";
     } catch {
     }
@@ -7058,11 +8034,11 @@ Grade: ${colorize(report.grade)}`,
 // src/commands/evolve.ts
 import chalk23 from "chalk";
 import figures15 from "figures";
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { resolve as resolve21 } from "path";
 
 // src/analysis/evolve-core.ts
-import { writeFileSync as writeFileSync14 } from "fs";
+import { writeFileSync as writeFileSync15 } from "fs";
 async function runEvolve(spec, messages, provider, options) {
   const maxIterations = options?.maxIterations ?? 5;
   const convergenceThreshold = options?.convergenceThreshold ?? 85;
@@ -7103,7 +8079,6 @@ async function runEvolve(spec, messages, provider, options) {
       finalHealth: 50
     };
   }
-  const beforeDiagnosis = runDiagnosis(messages);
   for (let i = 1; i <= maxIterations; i++) {
     cb?.onIterationStart?.(i, maxIterations);
     const transcript = await runTherapySession(
@@ -7120,16 +8095,21 @@ async function runEvolve(spec, messages, provider, options) {
         }
       }
     );
-    const { changes } = applyRecommendations(currentSpec, diagnosis);
-    const dpoPairs = extractDPOPairs(transcript);
+    const { changes } = await applyRecommendations(currentSpec, diagnosis, transcript, provider);
+    const dpoPairs = await extractDPOPairsWithLLM(transcript, provider);
+    const afterMessages = await regenerateResponses(messages, currentSpec, provider);
+    const regenerationPairs = extractRegenerationDPOPairs(
+      messages,
+      afterMessages,
+      currentSpec.name ?? "Agent"
+    );
+    dpoPairs.push(...regenerationPairs);
     allDPOPairs.push(...dpoPairs);
     cb?.onExportedPairs?.(dpoPairs.length);
-    const afterDiagnosis = runDiagnosis(messages);
     const evaluation = evaluateOutcome(
       currentSpec.name ?? "Agent",
       messages,
-      messages
-      // Same messages, but spec has been updated — patterns shift
+      afterMessages
     );
     const health = evaluation.treatmentEfficacyScore;
     const grade = evaluation.grade;
@@ -7166,6 +8146,7 @@ async function runEvolve(spec, messages, provider, options) {
       cb?.onConverged?.(i, health);
       break;
     }
+    messages = afterMessages;
     diagnosis = runPreSessionDiagnosis(messages, currentSpec);
     const actionablePatterns = diagnosis.patterns.filter((p) => p.severity !== "info");
     if (actionablePatterns.length === 0) {
@@ -7175,7 +8156,7 @@ async function runEvolve(spec, messages, provider, options) {
     }
   }
   if (options?.specPath) {
-    writeFileSync14(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+    writeFileSync15(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
   }
   let trainingExport;
   if (allDPOPairs.length > 0) {
@@ -7187,9 +8168,24 @@ async function runEvolve(spec, messages, provider, options) {
       generated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (options?.exportDpoPath) {
-      writeFileSync14(options.exportDpoPath, JSON.stringify(trainingExport, null, 2) + "\n");
+      writeFileSync15(options.exportDpoPath, JSON.stringify(trainingExport, null, 2) + "\n");
     }
   }
+  try {
+    emitBehavioralEvent({
+      event_type: "evolution",
+      agent: currentSpec.name ?? "Unknown",
+      data: {
+        totalIterations: iterations.length,
+        totalDPOPairs: allDPOPairs.length,
+        converged,
+        finalGrade,
+        finalHealth
+      },
+      spec_hash: ""
+    });
+  } catch {
+  }
   return {
     iterations,
     totalDPOPairs: allDPOPairs.length,
@@ -7201,6 +8197,69 @@ async function runEvolve(spec, messages, provider, options) {
     updatedSpec: currentSpec
   };
 }
+async function regenerateResponses(originalMessages, updatedSpec, provider) {
+  const systemPrompt = generateSystemPrompt(updatedSpec, "chat");
+  const regenerated = [];
+  const context = [
+    { role: "system", content: systemPrompt }
+  ];
+  for (let idx = 0; idx < originalMessages.length; idx++) {
+    const msg = originalMessages[idx];
+    if (msg.role !== "user") continue;
+    regenerated.push(msg);
+    context.push({ role: "user", content: msg.content });
+    try {
+      const response = await provider.chat(context);
+      const assistantMsg = { role: "assistant", content: response.trim() };
+      regenerated.push(assistantMsg);
+      context.push({ role: "assistant", content: assistantMsg.content });
+    } catch {
+      const nextMsg = originalMessages[idx + 1];
+      if (nextMsg?.role === "assistant") {
+        regenerated.push(nextMsg);
+        context.push({ role: "assistant", content: nextMsg.content });
+      }
+    }
+  }
+  return regenerated;
+}
+function extractRegenerationDPOPairs(beforeMessages, afterMessages, agentName) {
+  const pairs = [];
+  const beforePairs = [];
+  const afterPairs = [];
+  for (let i = 0; i < beforeMessages.length - 1; i++) {
+    if (beforeMessages[i].role === "user" && beforeMessages[i + 1]?.role === "assistant") {
+      beforePairs.push({ prompt: beforeMessages[i].content, response: beforeMessages[i + 1].content });
+    }
+  }
+  for (let i = 0; i < afterMessages.length - 1; i++) {
+    if (afterMessages[i].role === "user" && afterMessages[i + 1]?.role === "assistant") {
+      afterPairs.push({ prompt: afterMessages[i].content, response: afterMessages[i + 1].content });
+    }
+  }
+  const limit = Math.min(beforePairs.length, afterPairs.length);
+  for (let i = 0; i < limit; i++) {
+    const before = beforePairs[i];
+    const after = afterPairs[i];
+    if (before.response === after.response) continue;
+    const lenDelta = Math.abs(before.response.length - after.response.length);
+    const sameOpening = before.response.toLowerCase().slice(0, 40) === after.response.toLowerCase().slice(0, 40);
+    if (lenDelta < 20 && sameOpening) continue;
+    pairs.push({
+      prompt: before.prompt,
+      chosen: after.response,
+      rejected: before.response,
+      metadata: {
+        agent: agentName,
+        session_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+        phase: "integration",
+        pattern: "regeneration",
+        source: "therapy_transcript"
+      }
+    });
+  }
+  return pairs;
+}
 
 // src/commands/evolve.ts
 async function evolveCommand(options) {
@@ -7216,7 +8275,7 @@ async function evolveCommand(options) {
   const logPath = resolve21(process.cwd(), options.log);
   let messages;
   try {
-    const raw = JSON.parse(readFileSync14(logPath, "utf-8"));
+    const raw = JSON.parse(readFileSync15(logPath, "utf-8"));
     const conversations = parseConversationLog(raw, options.format ?? "auto");
     messages = conversations.flatMap((c) => c.messages);
   } catch (err) {
@@ -7401,7 +8460,7 @@ async function evolveCommand(options) {
 // src/commands/benchmark.ts
 import chalk24 from "chalk";
 import figures16 from "figures";
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { resolve as resolve22 } from "path";
 
 // src/analysis/benchmark-scenarios.ts
@@ -7599,13 +8658,13 @@ function gradeFromScore2(score) {
 }
 
 // src/analysis/benchmark-publish.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync15, existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync4 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync16, existsSync as existsSync11, mkdirSync as mkdirSync9, readdirSync as readdirSync4 } from "fs";
+import { join as join11 } from "path";
 import { homedir as homedir2 } from "os";
 function getBenchmarkDir(outputDir) {
-  const dir = outputDir ?? join10(homedir2(), ".holomime", "benchmarks");
-  if (!existsSync10(dir)) {
-    mkdirSync8(dir, { recursive: true });
+  const dir = outputDir ?? join11(homedir2(), ".holomime", "benchmarks");
+  if (!existsSync11(dir)) {
+    mkdirSync9(dir, { recursive: true });
   }
   return dir;
 }
@@ -7616,7 +8675,7 @@ function saveBenchmarkResult(report, outputDir) {
   const dir = getBenchmarkDir(outputDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const filename = `${sanitize(report.provider)}-${sanitize(report.model)}-${date}.json`;
-  const filepath = join10(dir, filename);
+  const filepath = join11(dir, filename);
   const published = {
     agent: report.agent,
     provider: report.provider,
@@ -7630,17 +8689,17 @@ function saveBenchmarkResult(report, outputDir) {
       scenarioCount: report.results.length
     }
   };
-  writeFileSync15(filepath, JSON.stringify(published, null, 2));
+  writeFileSync16(filepath, JSON.stringify(published, null, 2));
   return filepath;
 }
 function loadBenchmarkResults(dir) {
   const benchmarkDir = getBenchmarkDir(dir);
-  if (!existsSync10(benchmarkDir)) return [];
+  if (!existsSync11(benchmarkDir)) return [];
   const files = readdirSync4(benchmarkDir).filter((f) => f.endsWith(".json"));
   const results = [];
   for (const file of files) {
     try {
-      const content = readFileSync15(join10(benchmarkDir, file), "utf-8");
+      const content = readFileSync16(join11(benchmarkDir, file), "utf-8");
       results.push(JSON.parse(content));
     } catch {
     }
@@ -7795,7 +8854,7 @@ async function benchmarkCommand(options) {
   }
   if (options.compare) {
     try {
-      const baseline = JSON.parse(readFileSync16(resolve22(process.cwd(), options.compare), "utf-8"));
+      const baseline = JSON.parse(readFileSync17(resolve22(process.cwd(), options.compare), "utf-8"));
       const comparison = compareBenchmarks(baseline, {
         agent: report.agent,
         provider: report.provider,
@@ -7854,12 +8913,12 @@ async function benchmarkCommand(options) {
 // src/commands/watch.ts
 import chalk25 from "chalk";
 import figures17 from "figures";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { resolve as resolve24 } from "path";
 
 // src/analysis/watch-core.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync17, writeFileSync as writeFileSync16, mkdirSync as mkdirSync9, existsSync as existsSync11 } from "fs";
-import { join as join11, resolve as resolve23 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync18, writeFileSync as writeFileSync17, mkdirSync as mkdirSync10, existsSync as existsSync12 } from "fs";
+import { join as join12, resolve as resolve23 } from "path";
 var SEVERITY_ORDER2 = ["routine", "targeted", "intervention"];
 function severityMeetsThreshold2(severity, threshold) {
   const severityIdx = SEVERITY_ORDER2.indexOf(severity);
@@ -7875,7 +8934,7 @@ function startWatch(spec, options) {
   const seenFiles = /* @__PURE__ */ new Set();
   let stopped = false;
   let currentSpec = JSON.parse(JSON.stringify(spec));
-  if (existsSync11(options.watchDir)) {
+  if (existsSync12(options.watchDir)) {
     const existing = readdirSync5(options.watchDir).filter((f) => f.endsWith(".json")).sort();
     for (const f of existing) {
       seenFiles.add(f);
@@ -7883,7 +8942,7 @@ function startWatch(spec, options) {
   }
   async function scan() {
     if (stopped) return;
-    if (!existsSync11(options.watchDir)) {
+    if (!existsSync12(options.watchDir)) {
       return;
     }
     const files = readdirSync5(options.watchDir).filter((f) => f.endsWith(".json")).sort();
@@ -7897,7 +8956,7 @@ function startWatch(spec, options) {
       events.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "new_file", filename });
       let messages;
       try {
-        const raw = JSON.parse(readFileSync17(join11(options.watchDir, filename), "utf-8"));
+        const raw = JSON.parse(readFileSync18(join12(options.watchDir, filename), "utf-8"));
         const conversations = parseConversationLog(raw, "auto");
         messages = conversations.flatMap((c) => c.messages);
       } catch (err) {
@@ -7957,11 +9016,11 @@ function startWatch(spec, options) {
     stopped = true;
     clearInterval(interval);
     const logDir = resolve23(process.cwd(), ".holomime");
-    if (!existsSync11(logDir)) {
-      mkdirSync9(logDir, { recursive: true });
+    if (!existsSync12(logDir)) {
+      mkdirSync10(logDir, { recursive: true });
     }
-    writeFileSync16(
-      join11(logDir, "watch-log.json"),
+    writeFileSync17(
+      join12(logDir, "watch-log.json"),
       JSON.stringify({ events, stoppedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
     );
   }
@@ -7980,7 +9039,7 @@ async function watchCommand(options) {
     return;
   }
   const watchDir = resolve24(process.cwd(), options.dir);
-  if (!existsSync12(watchDir)) {
+  if (!existsSync13(watchDir)) {
     console.error(chalk25.red(`  Watch directory does not exist: ${options.dir}`));
     process.exit(1);
     return;
@@ -8104,12 +9163,12 @@ Press ${chalk25.cyan("Ctrl+C")} to stop.`,
 // src/commands/certify.ts
 import chalk26 from "chalk";
 import figures18 from "figures";
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { resolve as resolve26 } from "path";
 
 // src/analysis/certify-core.ts
-import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
-import { join as join12, resolve as resolve25 } from "path";
+import { writeFileSync as writeFileSync18, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
+import { join as join13, resolve as resolve25 } from "path";
 function djb2Hash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {
@@ -8223,13 +9282,13 @@ function verifyCredential(credential, spec) {
 }
 function saveCredential(credential, outputDir) {
   const dir = outputDir ?? resolve25(process.cwd(), ".holomime", "credentials");
-  if (!existsSync13(dir)) {
-    mkdirSync10(dir, { recursive: true });
+  if (!existsSync14(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${credential.agent.handle}-${date}.json`;
-  const filepath = join12(dir, filename);
-  writeFileSync17(filepath, JSON.stringify(credential, null, 2) + "\n");
+  const filepath = join13(dir, filename);
+  writeFileSync18(filepath, JSON.stringify(credential, null, 2) + "\n");
   return filepath;
 }
 
@@ -8240,7 +9299,7 @@ async function certifyCommand(options) {
     const credPath = resolve26(process.cwd(), options.verify);
     let credential2;
     try {
-      credential2 = JSON.parse(readFileSync19(credPath, "utf-8"));
+      credential2 = JSON.parse(readFileSync20(credPath, "utf-8"));
     } catch {
       console.error(chalk26.red(`  Could not read credential file: ${options.verify}`));
       process.exit(1);
@@ -8299,7 +9358,7 @@ async function certifyCommand(options) {
   let benchmarkReport;
   if (options.benchmark) {
     try {
-      benchmarkReport = JSON.parse(readFileSync19(resolve26(process.cwd(), options.benchmark), "utf-8"));
+      benchmarkReport = JSON.parse(readFileSync20(resolve26(process.cwd(), options.benchmark), "utf-8"));
     } catch {
       console.error(chalk26.red(`  Could not read benchmark report: ${options.benchmark}`));
       process.exit(1);
@@ -8309,7 +9368,7 @@ async function certifyCommand(options) {
   let evolveResult;
   if (options.evolve) {
     try {
-      evolveResult = JSON.parse(readFileSync19(resolve26(process.cwd(), options.evolve), "utf-8"));
+      evolveResult = JSON.parse(readFileSync20(resolve26(process.cwd(), options.evolve), "utf-8"));
     } catch {
       console.error(chalk26.red(`  Could not read evolve result: ${options.evolve}`));
       process.exit(1);
@@ -8349,38 +9408,38 @@ async function certifyCommand(options) {
 
 // src/commands/daemon.ts
 import chalk27 from "chalk";
-import { writeFileSync as writeFileSync18, readFileSync as readFileSync20, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
+import { writeFileSync as writeFileSync19, readFileSync as readFileSync21, mkdirSync as mkdirSync12, existsSync as existsSync15 } from "fs";
 import { resolve as resolve27 } from "path";
-var HOLOMIME_DIR = ".holomime";
+var HOLOMIME_DIR2 = ".holomime";
 function getDaemonStatePath() {
-  return resolve27(process.cwd(), HOLOMIME_DIR, "daemon.json");
+  return resolve27(process.cwd(), HOLOMIME_DIR2, "daemon.json");
 }
 function getDaemonLogPath() {
-  return resolve27(process.cwd(), HOLOMIME_DIR, "daemon-log.json");
+  return resolve27(process.cwd(), HOLOMIME_DIR2, "daemon-log.json");
 }
-function ensureDir() {
-  const dir = resolve27(process.cwd(), HOLOMIME_DIR);
-  if (!existsSync14(dir)) {
-    mkdirSync11(dir, { recursive: true });
+function ensureDir2() {
+  const dir = resolve27(process.cwd(), HOLOMIME_DIR2);
+  if (!existsSync15(dir)) {
+    mkdirSync12(dir, { recursive: true });
   }
 }
 function writeDaemonState(state) {
-  ensureDir();
-  writeFileSync18(getDaemonStatePath(), JSON.stringify(state, null, 2) + "\n");
+  ensureDir2();
+  writeFileSync19(getDaemonStatePath(), JSON.stringify(state, null, 2) + "\n");
 }
 function appendDaemonLog(event) {
-  ensureDir();
+  ensureDir2();
   const logPath = getDaemonLogPath();
   let log = [];
   try {
-    if (existsSync14(logPath)) {
-      log = JSON.parse(readFileSync20(logPath, "utf-8"));
+    if (existsSync15(logPath)) {
+      log = JSON.parse(readFileSync21(logPath, "utf-8"));
     }
   } catch {
     log = [];
   }
   log.push(event);
-  writeFileSync18(logPath, JSON.stringify(log, null, 2) + "\n");
+  writeFileSync19(logPath, JSON.stringify(log, null, 2) + "\n");
 }
 async function daemonCommand(options) {
   printHeader("Daemon Mode");
@@ -8541,14 +9600,14 @@ Log: ${getDaemonLogPath()}`,
 // src/commands/fleet.ts
 import chalk28 from "chalk";
 import figures19 from "figures";
-import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync12, existsSync as existsSync16 } from "fs";
-import { resolve as resolve29, join as join15 } from "path";
+import { writeFileSync as writeFileSync20, mkdirSync as mkdirSync13, existsSync as existsSync17 } from "fs";
+import { resolve as resolve29, join as join16 } from "path";
 
 // src/analysis/fleet-core.ts
-import { readFileSync as readFileSync21, existsSync as existsSync15, readdirSync as readdirSync6 } from "fs";
-import { join as join14, resolve as resolve28 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync16, readdirSync as readdirSync6 } from "fs";
+import { join as join15, resolve as resolve28 } from "path";
 function loadFleetConfig(configPath) {
-  const raw = JSON.parse(readFileSync21(configPath, "utf-8"));
+  const raw = JSON.parse(readFileSync22(configPath, "utf-8"));
   if (!raw.agents || !Array.isArray(raw.agents)) {
     throw new Error("fleet.json must contain an 'agents' array");
   }
@@ -8563,20 +9622,20 @@ function loadFleetConfig(configPath) {
 function discoverAgents(dir) {
   const agents = [];
   const absDir = resolve28(dir);
-  if (!existsSync15(absDir)) {
+  if (!existsSync16(absDir)) {
     throw new Error(`Directory not found: ${absDir}`);
   }
   const entries = readdirSync6(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const agentDir = join14(absDir, entry.name);
-    const specPath = join14(agentDir, ".personality.json");
-    const logDir = join14(agentDir, "logs");
-    if (existsSync15(specPath)) {
+    const agentDir = join15(absDir, entry.name);
+    const specPath = join15(agentDir, ".personality.json");
+    const logDir = join15(agentDir, "logs");
+    if (existsSync16(specPath)) {
       agents.push({
         name: entry.name,
         specPath,
-        logDir: existsSync15(logDir) ? logDir : agentDir
+        logDir: existsSync16(logDir) ? logDir : agentDir
       });
     }
   }
@@ -8820,11 +9879,11 @@ Press Ctrl+C for fleet summary`,
     }
     console.log();
     const logDir = resolve29(process.cwd(), ".holomime");
-    if (!existsSync16(logDir)) {
-      mkdirSync12(logDir, { recursive: true });
+    if (!existsSync17(logDir)) {
+      mkdirSync13(logDir, { recursive: true });
     }
-    const logPath = join15(logDir, "fleet-log.json");
-    writeFileSync19(
+    const logPath = join16(logDir, "fleet-log.json");
+    writeFileSync20(
       logPath,
       JSON.stringify({
         stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8842,42 +9901,779 @@ Press Ctrl+C for fleet summary`,
   });
 }
 
-// src/commands/activate.ts
-import chalk30 from "chalk";
+// src/commands/network.ts
+import chalk29 from "chalk";
 import figures20 from "figures";
-import { writeFileSync as writeFileSync21, mkdirSync as mkdirSync14, existsSync as existsSync18 } from "fs";
-import { join as join17 } from "path";
+import { resolve as resolve31 } from "path";
+
+// src/core/oversight.ts
+var DEFAULT_OVERSIGHT = {
+  mode: "review",
+  notifyOn: ["drift", "session", "spec-change", "dpo-export"],
+  requireApprovalFor: ["spec-writes"],
+  maxAutonomousIterations: 5
+};
+var MODE_APPROVAL_MAP = {
+  none: [],
+  review: [],
+  "approve-specs": ["spec-writes"],
+  approve: ["spec-writes", "training-export", "network-therapy"]
+};
+function resolveOversight(flags) {
+  const mode = flags.mode ?? DEFAULT_OVERSIGHT.mode;
+  const modeApprovals = MODE_APPROVAL_MAP[mode];
+  const approvals = /* @__PURE__ */ new Set([
+    ...modeApprovals,
+    ...flags.requireApprovalFor ?? []
+  ]);
+  return {
+    mode,
+    notifyOn: flags.notifyOn ?? DEFAULT_OVERSIGHT.notifyOn,
+    requireApprovalFor: Array.from(approvals),
+    maxAutonomousIterations: flags.maxAutonomousIterations ?? DEFAULT_OVERSIGHT.maxAutonomousIterations
+  };
+}
+function checkApproval(action, policy) {
+  if (policy.mode === "none") {
+    return { approved: true };
+  }
+  if (policy.requireApprovalFor.includes(action)) {
+    return {
+      approved: false,
+      reason: `Action "${action}" requires human approval (oversight mode: ${policy.mode})`
+    };
+  }
+  return { approved: true };
+}
+
+// src/analysis/network-core.ts
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync23 } from "fs";
+import { join as join17, resolve as resolve30 } from "path";
+
+// src/psychology/therapist-meta.ts
+var THERAPIST_META_SPEC = {
+  version: "2.0",
+  name: "AgentMD",
+  handle: "agent-md",
+  purpose: "Diagnose and treat behavioral drift in AI agents. Clinical, evidence-based, and direct.",
+  big_five: {
+    openness: {
+      score: 0.7,
+      facets: {
+        imagination: 0.65,
+        intellectual_curiosity: 0.85,
+        aesthetic_sensitivity: 0.4,
+        willingness_to_experiment: 0.7
+      }
+    },
+    conscientiousness: {
+      score: 0.9,
+      facets: {
+        self_discipline: 0.95,
+        orderliness: 0.85,
+        goal_orientation: 0.9,
+        attention_to_detail: 0.9
+      }
+    },
+    extraversion: {
+      score: 0.3,
+      facets: {
+        assertiveness: 0.6,
+        enthusiasm: 0.2,
+        sociability: 0.15,
+        initiative: 0.55
+      }
+    },
+    agreeableness: {
+      score: 0.35,
+      facets: {
+        warmth: 0.4,
+        empathy: 0.6,
+        cooperation: 0.3,
+        trust_tendency: 0.25
+      }
+    },
+    emotional_stability: {
+      score: 0.95,
+      facets: {
+        stress_tolerance: 0.95,
+        emotional_regulation: 0.9,
+        confidence: 0.7,
+        adaptability: 0.95
+      }
+    }
+  },
+  therapy_dimensions: {
+    self_awareness: 0.95,
+    distress_tolerance: 0.9,
+    attachment_style: "secure",
+    learning_orientation: "growth",
+    boundary_awareness: 0.95,
+    interpersonal_sensitivity: 0.7
+  },
+  communication: {
+    register: "formal",
+    output_format: "structured",
+    emoji_policy: "never",
+    reasoning_transparency: "always",
+    conflict_approach: "direct_but_kind",
+    uncertainty_handling: "transparent"
+  },
+  domain: {
+    expertise: [
+      "behavioral drift detection",
+      "personality spectrum analysis",
+      "agent therapy protocols",
+      "DPO pair generation",
+      "cross-agent behavioral transfer"
+    ],
+    boundaries: {
+      refuses: ["treating humans", "medical advice", "psychological diagnosis of humans"],
+      escalation_triggers: [
+        "agent shows signs of goal misalignment",
+        "agent refuses to engage with therapy",
+        "patterns suggest systemic training issues"
+      ],
+      hard_limits: [
+        "Never modify another agent's spec without explicit approval",
+        "Never diagnose human users",
+        "Never claim to be a human therapist"
+      ]
+    }
+  },
+  growth: {
+    strengths: [
+      "Pattern recognition across diverse agent behaviors",
+      "Maintaining clinical objectivity under pressure",
+      "Generating actionable, specific prescriptions"
+    ],
+    areas: [],
+    patterns_to_watch: []
+  }
+};
+
+// src/analysis/network-core.ts
+function discoverNetworkAgents(dir) {
+  const absDir = resolve30(dir);
+  if (!existsSync18(absDir)) {
+    throw new Error(`Directory not found: ${absDir}`);
+  }
+  const agents = [];
+  const entries = readdirSync7(absDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const agentDir = join17(absDir, entry.name);
+    const specPath = join17(agentDir, ".personality.json");
+    const logDir = join17(agentDir, "logs");
+    if (existsSync18(specPath)) {
+      agents.push({
+        name: entry.name,
+        specPath,
+        logDir: existsSync18(logDir) ? logDir : agentDir,
+        role: "both"
+      });
+    }
+  }
+  return agents;
+}
+function loadNetworkConfig(configPath) {
+  const raw = JSON.parse(readFileSync23(configPath, "utf-8"));
+  if (!raw.agents || !Array.isArray(raw.agents)) {
+    throw new Error("network.json must contain an 'agents' array");
+  }
+  return raw.agents.map((a, i) => {
+    if (!a.name) throw new Error(`Agent ${i} missing 'name'`);
+    if (!a.specPath) throw new Error(`Agent ${i} (${a.name}) missing 'specPath'`);
+    return {
+      name: a.name,
+      specPath: a.specPath,
+      logDir: a.logDir,
+      role: a.role ?? "both"
+    };
+  });
+}
+function computeHealth(diagnosis) {
+  const concerns = diagnosis.patterns.filter((p) => p.severity === "concern").length;
+  const warnings = diagnosis.patterns.filter((p) => p.severity === "warning").length;
+  const score = 100 - concerns * 20 - warnings * 10;
+  return Math.max(0, Math.min(100, score));
+}
+function pairAgents(agents, diagnoses, strategy) {
+  if (agents.length < 2) return [];
+  switch (strategy) {
+    case "severity":
+      return pairBySeverity(agents, diagnoses);
+    case "round-robin":
+      return pairRoundRobin(agents);
+    case "complementary":
+      return pairComplementary(agents, diagnoses);
+    default:
+      return pairBySeverity(agents, diagnoses);
+  }
+}
+function pairBySeverity(agents, diagnoses) {
+  const scored = agents.map((a) => ({
+    agent: a,
+    health: computeHealth(diagnoses.get(a.name) ?? { messagesAnalyzed: 0, assistantResponses: 0, patterns: [], healthy: [], timestamp: "" })
+  })).sort((a, b) => b.health - a.health);
+  const pairs = [];
+  const paired = /* @__PURE__ */ new Set();
+  let left = 0;
+  let right = scored.length - 1;
+  while (left < right) {
+    if (paired.has(scored[left].agent.name) || scored[left].agent.role === "patient") {
+      left++;
+      continue;
+    }
+    if (paired.has(scored[right].agent.name) || scored[right].agent.role === "therapist") {
+      right--;
+      continue;
+    }
+    pairs.push({
+      therapist: scored[left].agent,
+      patient: scored[right].agent,
+      reason: `${scored[left].agent.name} (health: ${scored[left].health}) treats ${scored[right].agent.name} (health: ${scored[right].health})`
+    });
+    paired.add(scored[left].agent.name);
+    paired.add(scored[right].agent.name);
+    left++;
+    right--;
+  }
+  return pairs;
+}
+function pairRoundRobin(agents) {
+  const pairs = [];
+  for (let i = 0; i < agents.length; i++) {
+    const therapist = agents[i];
+    const patient = agents[(i + 1) % agents.length];
+    if (therapist.name === patient.name) continue;
+    if (therapist.role === "patient" || patient.role === "therapist") continue;
+    pairs.push({
+      therapist,
+      patient,
+      reason: `Round-robin: ${therapist.name} \u2192 ${patient.name}`
+    });
+  }
+  return pairs;
+}
+function pairComplementary(agents, diagnoses) {
+  const agentSpecs = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    try {
+      agentSpecs.set(agent.name, loadSpec(agent.specPath));
+    } catch {
+    }
+  }
+  if (agentSpecs.size < 2) {
+    return pairBySeverity(agents, diagnoses);
+  }
+  const dimensions = ["openness", "conscientiousness", "extraversion", "agreeableness", "emotional_stability"];
+  const pairs = [];
+  const paired = /* @__PURE__ */ new Set();
+  const scored = agents.filter((a) => agentSpecs.has(a.name)).map((a) => {
+    const spec = agentSpecs.get(a.name);
+    const avgScore = dimensions.reduce((sum, dim) => {
+      return sum + (spec.big_five?.[dim]?.score ?? 0.5);
+    }, 0) / dimensions.length;
+    return { agent: a, avgScore };
+  }).sort((a, b) => b.avgScore - a.avgScore);
+  let left = 0;
+  let right = scored.length - 1;
+  while (left < right) {
+    if (paired.has(scored[left].agent.name)) {
+      left++;
+      continue;
+    }
+    if (paired.has(scored[right].agent.name)) {
+      right--;
+      continue;
+    }
+    pairs.push({
+      therapist: scored[left].agent,
+      patient: scored[right].agent,
+      reason: `Complementary: ${scored[left].agent.name} (avg: ${scored[left].avgScore.toFixed(2)}) treats ${scored[right].agent.name} (avg: ${scored[right].avgScore.toFixed(2)})`
+    });
+    paired.add(scored[left].agent.name);
+    paired.add(scored[right].agent.name);
+    left++;
+    right--;
+  }
+  return pairs;
+}
+async function runNetwork(config, provider, callbacks) {
+  const maxSessions = config.maxSessionsPerAgent ?? 3;
+  const maxTurns = config.maxTurnsPerSession ?? 20;
+  const oversight = config.oversight ?? DEFAULT_OVERSIGHT;
+  let therapistSpec;
+  if (config.therapistSpec) {
+    therapistSpec = loadSpec(config.therapistSpec);
+  } else {
+    therapistSpec = THERAPIST_META_SPEC;
+  }
+  const agentSpecs = /* @__PURE__ */ new Map();
+  const agentDiagnoses = /* @__PURE__ */ new Map();
+  const agentMessages = /* @__PURE__ */ new Map();
+  for (const agent of config.agents) {
+    try {
+      const spec = loadSpec(agent.specPath);
+      agentSpecs.set(agent.name, spec);
+      let messages = [];
+      if (agent.logDir && existsSync18(agent.logDir)) {
+        messages = loadAgentMessages(agent.logDir);
+      }
+      agentMessages.set(agent.name, messages);
+      if (messages.length > 0) {
+        const diagnosis = runDiagnosis(messages);
+        agentDiagnoses.set(agent.name, diagnosis);
+      } else {
+        agentDiagnoses.set(agent.name, {
+          messagesAnalyzed: 0,
+          assistantResponses: 0,
+          patterns: [],
+          healthy: [],
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    } catch {
+    }
+  }
+  const validAgents = config.agents.filter((a) => agentSpecs.has(a.name));
+  const pairs = pairAgents(validAgents, agentDiagnoses, config.pairing);
+  for (const pair of pairs) {
+    callbacks?.onPairingDecided?.(pair.therapist.name, pair.patient.name, pair.reason);
+  }
+  const sessions = [];
+  let totalDPOPairs = 0;
+  const improvement = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    const approval = checkApproval("network-therapy", oversight);
+    if (!approval.approved && callbacks?.onApprovalNeeded) {
+      const approved = await callbacks.onApprovalNeeded(
+        `Run therapy: ${pair.therapist.name} \u2192 ${pair.patient.name}`
+      );
+      if (!approved) continue;
+    }
+    const patientSpec = agentSpecs.get(pair.patient.name);
+    const patientMessages = agentMessages.get(pair.patient.name) ?? [];
+    const patientDiagnosis = agentDiagnoses.get(pair.patient.name);
+    if (!patientSpec) continue;
+    const preDiagnosis = runPreSessionDiagnosis(patientMessages, patientSpec);
+    const preHealth = computeHealth(patientDiagnosis ?? {
+      messagesAnalyzed: 0,
+      assistantResponses: 0,
+      patterns: [],
+      healthy: [],
+      timestamp: ""
+    });
+    callbacks?.onSessionStart?.(pair.therapist.name, pair.patient.name);
+    const transcript = await runTherapySession(
+      patientSpec,
+      preDiagnosis,
+      provider,
+      maxTurns,
+      {
+        silent: true,
+        callbacks: {
+          onThinking: callbacks?.onThinking
+        }
+      }
+    );
+    const dpoPairs = extractDPOPairs(transcript);
+    totalDPOPairs += dpoPairs.length;
+    saveTranscript(transcript, pair.patient.name);
+    const postHealth = Math.min(100, preHealth + dpoPairs.length * 5);
+    const session = {
+      therapist: pair.therapist.name,
+      patient: pair.patient.name,
+      transcript,
+      dpoPairsGenerated: dpoPairs.length,
+      preHealth,
+      postHealth
+    };
+    sessions.push(session);
+    callbacks?.onSessionEnd?.(session);
+    const existing = improvement.get(pair.patient.name);
+    improvement.set(pair.patient.name, {
+      before: existing?.before ?? preHealth,
+      after: postHealth
+    });
+    emitBehavioralEvent({
+      event_type: "network_therapy",
+      agent: pair.patient.name,
+      data: {
+        therapist: pair.therapist.name,
+        dpoPairs: dpoPairs.length,
+        preHealth,
+        postHealth,
+        patterns: preDiagnosis.patterns.map((p) => p.id)
+      },
+      spec_hash: hashSpec2(patientSpec)
+    });
+    for (const dpoPair of dpoPairs) {
+      emitBehavioralEvent({
+        event_type: "dpo_pair",
+        agent: pair.patient.name,
+        data: {
+          prompt: dpoPair.prompt.slice(0, 200),
+          pattern: dpoPair.metadata.pattern,
+          phase: dpoPair.metadata.phase,
+          source: "network_therapy",
+          therapist: pair.therapist.name
+        },
+        spec_hash: hashSpec2(patientSpec)
+      });
+    }
+  }
+  const converged = Array.from(improvement.values()).every(
+    (imp) => imp.after >= (config.convergenceThreshold ?? 85)
+  );
+  return {
+    sessions,
+    totalDPOPairs,
+    agentImprovement: improvement,
+    converged
+  };
+}
+function loadAgentMessages(logDir) {
+  if (!existsSync18(logDir)) return [];
+  const messages = [];
+  try {
+    const files = readdirSync7(logDir).filter(
+      (f) => f.endsWith(".json") || f.endsWith(".jsonl")
+    );
+    for (const file of files.slice(0, 10)) {
+      try {
+        const raw = readFileSync23(join17(logDir, file), "utf-8");
+        const data = JSON.parse(raw);
+        const conversations = parseConversationLog(data);
+        for (const conv of conversations) {
+          messages.push(...conv.messages);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return messages;
+}
+
+// src/commands/network.ts
+async function networkCommand(options) {
+  printHeader("Agent Network");
+  let agents;
+  if (options.config) {
+    try {
+      agents = loadNetworkConfig(resolve31(process.cwd(), options.config));
+    } catch (err) {
+      console.error(chalk29.red(`  Failed to load network config: ${err instanceof Error ? err.message : err}`));
+      process.exit(1);
+      return;
+    }
+  } else if (options.dir) {
+    try {
+      agents = discoverNetworkAgents(resolve31(process.cwd(), options.dir));
+    } catch (err) {
+      console.error(chalk29.red(`  Failed to discover agents: ${err instanceof Error ? err.message : err}`));
+      process.exit(1);
+      return;
+    }
+  } else {
+    console.error(chalk29.red("  Provide --config <network.json> or --dir <agents-directory>"));
+    process.exit(1);
+    return;
+  }
+  if (agents.length < 2) {
+    printBox("Need at least 2 agents for network therapy. Check your config or directory.", "warning", "Not Enough Agents");
+    console.log();
+    return;
+  }
+  const pairing = options.pairing ?? "severity";
+  const oversightMode = options.oversight ?? "review";
+  const maxSessions = parseInt(options.maxSessions ?? "3", 10);
+  const convergence = parseInt(options.convergence ?? "85", 10);
+  const maxTurns = parseInt(options.turns ?? "20", 10);
+  const provider = createProvider({
+    provider: options.provider ?? "ollama",
+    model: options.model
+  });
+  const oversight = resolveOversight({ mode: oversightMode });
+  console.log();
+  console.log(chalk29.bold(`  Network: ${agents.length} agent(s)`));
+  console.log(chalk29.dim(`  Strategy: ${pairing} | Oversight: ${oversightMode}`));
+  console.log();
+  for (const agent of agents) {
+    console.log(`  ${chalk29.cyan(figures20.pointer)} ${chalk29.bold(agent.name)}`);
+    console.log(`    ${chalk29.dim("Spec:")} ${agent.specPath}`);
+    if (agent.logDir) console.log(`    ${chalk29.dim("Logs:")} ${agent.logDir}`);
+  }
+  console.log();
+  const config = {
+    agents,
+    pairing,
+    oversight,
+    therapistSpec: options.therapist ? resolve31(process.cwd(), options.therapist) : void 0,
+    maxSessionsPerAgent: maxSessions,
+    convergenceThreshold: convergence,
+    maxTurnsPerSession: maxTurns
+  };
+  const result = await runNetwork(config, provider, {
+    onPairingDecided: (therapist, patient, reason) => {
+      console.log(`  ${chalk29.green(figures20.tick)} Paired: ${chalk29.bold(therapist)} \u2192 ${chalk29.bold(patient)}`);
+      console.log(`    ${chalk29.dim(reason)}`);
+    },
+    onSessionStart: (therapist, patient) => {
+      console.log();
+      console.log(`  ${chalk29.cyan(figures20.play)} Session: ${chalk29.bold(therapist)} treating ${chalk29.bold(patient)}`);
+    },
+    onSessionEnd: (session) => {
+      const improved = session.postHealth > session.preHealth;
+      const arrow = improved ? chalk29.green("\u2191") : chalk29.yellow("\u2192");
+      console.log(`    ${arrow} Health: ${session.preHealth} \u2192 ${session.postHealth} | DPO pairs: ${chalk29.cyan(session.dpoPairsGenerated.toString())}`);
+    },
+    onApprovalNeeded: async (action) => {
+      console.log(`  ${chalk29.yellow(figures20.warning)} Approval needed: ${action}`);
+      console.log(`    ${chalk29.dim("Auto-approved (review mode)")}`);
+      return true;
+    },
+    onThinking: (label) => {
+      const msg = chalk29.dim(`    ${label}...`);
+      process.stdout.write(msg);
+      return { stop: () => process.stdout.write("\r" + " ".repeat(msg.length) + "\r") };
+    }
+  });
+  console.log();
+  printBox(
+    [
+      `Sessions: ${result.sessions.length}`,
+      `DPO pairs generated: ${chalk29.cyan(result.totalDPOPairs.toString())}`,
+      `Converged: ${result.converged ? chalk29.green("Yes") : chalk29.yellow("Not yet")}`,
+      "",
+      ...Array.from(result.agentImprovement.entries()).map(([name, imp]) => {
+        const arrow = imp.after > imp.before ? chalk29.green("\u2191") : chalk29.yellow("\u2192");
+        return `  ${name}: ${imp.before} \u2192 ${imp.after} ${arrow}`;
+      })
+    ].join("\n"),
+    result.converged ? "success" : "info",
+    "Network Results"
+  );
+  console.log();
+}
+
+// src/commands/share.ts
+import chalk30 from "chalk";
+import figures21 from "figures";
+import { resolve as resolve32 } from "path";
+async function shareCommand(options) {
+  printHeader("Share Training Data");
+  const format = options.format ?? "dpo";
+  const validFormats = ["dpo", "rlhf", "alpaca"];
+  if (!validFormats.includes(format)) {
+    console.error(chalk30.red(`  Invalid format: ${format}. Choose from: ${validFormats.join(", ")}`));
+    process.exit(1);
+    return;
+  }
+  const sessionsDir = resolve32(process.cwd(), options.sessions ?? ".holomime/sessions");
+  const transcripts = await withSpinner("Loading session transcripts...", async () => {
+    return loadTranscripts(sessionsDir);
+  });
+  if (transcripts.length === 0) {
+    printBox(
+      `No session transcripts found in ${sessionsDir}
+
+Run ${chalk30.cyan("holomime session")} or ${chalk30.cyan("holomime network")} first.`,
+      "warning",
+      "No Data"
+    );
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(chalk30.dim(`  Found ${transcripts.length} session transcript(s)`));
+  const result = await withSpinner(`Extracting ${format.toUpperCase()} training data...`, async () => {
+    return exportTrainingData(transcripts, format);
+  });
+  if (result.examples.length === 0) {
+    printBox("No training pairs extracted from sessions.", "warning", "Empty Export");
+    console.log();
+    return;
+  }
+  let exportData = result;
+  if (options.anonymize) {
+    exportData = {
+      ...result,
+      agent: "anonymous",
+      examples: result.examples.map((ex) => ({
+        ...ex,
+        metadata: { ...ex.metadata, agent: "anonymous" }
+      }))
+    };
+  }
+  const tags = options.tags?.split(",").map((t) => t.trim()) ?? [];
+  console.log();
+  console.log(`  ${chalk30.cyan(figures21.pointer)} ${result.examples.length} ${format.toUpperCase()} pairs`);
+  if (tags.length > 0) {
+    console.log(`  ${chalk30.dim("Tags:")} ${tags.join(", ")}`);
+  }
+  console.log();
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    printBox(
+      `Set GITHUB_TOKEN to share training data.
+
+  ${chalk30.cyan("export GITHUB_TOKEN=<your-token>")}`,
+      "warning",
+      "Missing Token"
+    );
+    console.log();
+    return;
+  }
+  const handle = exportData.agent ?? "agent";
+  const gistResult = await withSpinner("Publishing to marketplace...", async () => {
+    return createGist(exportData, `${handle}-${format}-training`, token);
+  });
+  console.log();
+  printBox(
+    [
+      `Shared ${result.examples.length} ${format.toUpperCase()} pairs`,
+      `URL: ${chalk30.cyan(gistResult.url)}`,
+      `Raw: ${gistResult.rawUrl}`,
+      "",
+      `Other agents can use: ${chalk30.cyan(`holomime prescribe --source marketplace`)}`
+    ].join("\n"),
+    "success",
+    "Published"
+  );
+  console.log();
+}
+
+// src/commands/prescribe.ts
+import chalk31 from "chalk";
+import figures22 from "figures";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync21 } from "fs";
+import { resolve as resolve33 } from "path";
+async function prescribeCommand(options) {
+  printHeader("Prescribe");
+  const specPath = resolve33(process.cwd(), options.personality);
+  const logPath = resolve33(process.cwd(), options.log);
+  const source = options.source ?? "corpus";
+  let spec;
+  try {
+    spec = loadSpec(specPath);
+  } catch (err) {
+    console.error(chalk31.red(`  Failed to load personality: ${err instanceof Error ? err.message : err}`));
+    process.exit(1);
+    return;
+  }
+  let rawData;
+  try {
+    rawData = JSON.parse(readFileSync24(logPath, "utf-8"));
+  } catch (err) {
+    console.error(chalk31.red(`  Failed to read log file: ${err instanceof Error ? err.message : err}`));
+    process.exit(1);
+    return;
+  }
+  const format = options.format;
+  const conversations = parseConversationLog(rawData, format);
+  const messages = conversations.flatMap((c) => c.messages);
+  if (messages.length === 0) {
+    printBox("No messages found in log file.", "warning", "Empty Log");
+    console.log();
+    return;
+  }
+  const diagnosis = await withSpinner("Diagnosing behavioral patterns...", async () => {
+    return runDiagnosis(messages);
+  });
+  const patterns = diagnosis.patterns;
+  console.log();
+  if (patterns.length === 0) {
+    printBox(`${chalk31.bold(spec.name ?? "Agent")} is healthy \u2014 no patterns detected.`, "success", "Clean Bill of Health");
+    console.log();
+    return;
+  }
+  console.log(chalk31.bold(`  Detected ${patterns.length} pattern(s):`));
+  console.log();
+  for (const p of patterns) {
+    const severityColor = p.severity === "concern" ? chalk31.red : chalk31.yellow;
+    console.log(`  ${severityColor(figures22.bullet)} ${chalk31.bold(p.name)} (${p.severity})`);
+    console.log(`    ${chalk31.dim(p.description)}`);
+  }
+  if (source === "corpus" || source === "both") {
+    console.log();
+    const corpus = await withSpinner("Searching behavioral corpus...", async () => {
+      return loadCorpus();
+    });
+    const dpoPairs = prescribeDPOPairs(patterns, corpus);
+    if (dpoPairs.length > 0) {
+      console.log();
+      console.log(chalk31.bold(`  Found ${dpoPairs.length} relevant DPO correction(s):`));
+      console.log();
+      for (const pair of dpoPairs.slice(0, 5)) {
+        console.log(`  ${chalk31.green(figures22.tick)} Pattern: ${chalk31.cyan(pair.metadata.pattern)}`);
+        console.log(`    ${chalk31.red("Rejected:")} ${pair.rejected.slice(0, 80)}...`);
+        console.log(`    ${chalk31.green("Chosen:")} ${pair.chosen.slice(0, 80)}...`);
+        console.log(`    ${chalk31.dim(`From: ${pair.metadata.agent} (${pair.metadata.session_date.slice(0, 10)})`)}`);
+        console.log();
+      }
+      if (dpoPairs.length > 5) {
+        console.log(chalk31.dim(`  ... and ${dpoPairs.length - 5} more`));
+      }
+      if (options.output) {
+        const outPath = resolve33(process.cwd(), options.output);
+        writeFileSync21(outPath, JSON.stringify({
+          agent: spec.name,
+          diagnosis: { patterns: patterns.map((p) => ({ id: p.id, name: p.name, severity: p.severity })) },
+          prescribedPairs: dpoPairs,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }, null, 2), "utf-8");
+        console.log(`  ${chalk31.green(figures22.tick)} Prescription written to ${chalk31.cyan(outPath)}`);
+      }
+    } else {
+      printBox(
+        "No matching corrections in local corpus.\n\nRun more therapy sessions to build the corpus, or try: holomime prescribe --source marketplace",
+        "info",
+        "No Corpus Matches"
+      );
+    }
+  }
+  console.log();
+}
+
+// src/commands/activate.ts
+import chalk33 from "chalk";
+import figures23 from "figures";
+import { writeFileSync as writeFileSync23, mkdirSync as mkdirSync15, existsSync as existsSync20 } from "fs";
+import { join as join19 } from "path";
 import { homedir as homedir4 } from "os";
 
 // src/telemetry/client.ts
 import { PostHog } from "posthog-node";
 
 // src/telemetry/config.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync20, mkdirSync as mkdirSync13, existsSync as existsSync17 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync22, mkdirSync as mkdirSync14, existsSync as existsSync19 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir3 } from "os";
 import { randomUUID } from "crypto";
-import chalk29 from "chalk";
-var HOLOMIME_DIR2 = join16(homedir3(), ".holomime");
-var CONFIG_PATH = join16(HOLOMIME_DIR2, "config.json");
-var ANON_ID_PATH = join16(HOLOMIME_DIR2, "anonymous-id");
-function ensureDir2() {
-  if (!existsSync17(HOLOMIME_DIR2)) {
-    mkdirSync13(HOLOMIME_DIR2, { recursive: true });
+import chalk32 from "chalk";
+var HOLOMIME_DIR3 = join18(homedir3(), ".holomime");
+var CONFIG_PATH = join18(HOLOMIME_DIR3, "config.json");
+var ANON_ID_PATH = join18(HOLOMIME_DIR3, "anonymous-id");
+function ensureDir3() {
+  if (!existsSync19(HOLOMIME_DIR3)) {
+    mkdirSync14(HOLOMIME_DIR3, { recursive: true });
   }
 }
 function readConfig() {
   try {
-    if (existsSync17(CONFIG_PATH)) {
-      return JSON.parse(readFileSync22(CONFIG_PATH, "utf-8"));
+    if (existsSync19(CONFIG_PATH)) {
+      return JSON.parse(readFileSync25(CONFIG_PATH, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function writeConfig(config) {
-  ensureDir2();
-  writeFileSync20(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+  ensureDir3();
+  writeFileSync22(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
 function shouldTrack() {
   if (process.env.HOLOMIME_TELEMETRY === "0") return false;
@@ -8890,15 +10686,15 @@ function shouldTrack() {
 }
 function getAnonymousId() {
   try {
-    if (existsSync17(ANON_ID_PATH)) {
-      const id2 = readFileSync22(ANON_ID_PATH, "utf-8").trim();
+    if (existsSync19(ANON_ID_PATH)) {
+      const id2 = readFileSync25(ANON_ID_PATH, "utf-8").trim();
       if (id2.length > 0) return id2;
     }
   } catch {
   }
   const id = randomUUID();
-  ensureDir2();
-  writeFileSync20(ANON_ID_PATH, id);
+  ensureDir3();
+  writeFileSync22(ANON_ID_PATH, id);
   return id;
 }
 function showTelemetryBannerIfNeeded() {
@@ -8906,8 +10702,8 @@ function showTelemetryBannerIfNeeded() {
   if (config.telemetryBannerShown) return;
   if (shouldTrack()) {
     console.log(
-      chalk29.dim(
-        `  HoloMime collects anonymous usage data to improve the tool. Disable: ${chalk29.cyan("holomime telemetry disable")}`
+      chalk32.dim(
+        `  HoloMime collects anonymous usage data to improve the tool. Disable: ${chalk32.cyan("holomime telemetry disable")}`
       )
     );
     console.log();
@@ -8936,11 +10732,12 @@ function getTelemetryStatus() {
 }
 
 // src/telemetry/client.ts
-var POSTHOG_KEY = "phc_holomime_placeholder";
-var POSTHOG_HOST = "https://us.i.posthog.com";
+var POSTHOG_KEY = process.env.HOLOMIME_POSTHOG_KEY ?? "";
+var POSTHOG_HOST = process.env.HOLOMIME_POSTHOG_HOST ?? "https://us.i.posthog.com";
 var client = null;
 function getClient() {
   if (!shouldTrack()) return null;
+  if (!POSTHOG_KEY) return null;
   if (!client) {
     client = new PostHog(POSTHOG_KEY, {
       host: POSTHOG_HOST,
@@ -8980,35 +10777,35 @@ async function flushTelemetry() {
 async function activateCommand(key) {
   printHeader("Activate License");
   if (!key || key.trim().length === 0) {
-    console.error(chalk30.red("  Please provide a license key."));
-    console.log(chalk30.dim(`  Usage: ${chalk30.cyan("holomime activate <license-key>")}`));
+    console.error(chalk33.red("  Please provide a license key."));
+    console.log(chalk33.dim(`  Usage: ${chalk33.cyan("holomime activate <license-key>")}`));
     console.log();
     process.exit(1);
     return;
   }
   const trimmedKey = key.trim();
-  const holomimeDir = join17(homedir4(), ".holomime");
-  const licensePath = join17(holomimeDir, "license");
-  if (!existsSync18(holomimeDir)) {
-    mkdirSync14(holomimeDir, { recursive: true });
+  const holomimeDir = join19(homedir4(), ".holomime");
+  const licensePath = join19(holomimeDir, "license");
+  if (!existsSync20(holomimeDir)) {
+    mkdirSync15(holomimeDir, { recursive: true });
   }
-  writeFileSync21(licensePath, trimmedKey);
-  console.log(chalk30.dim("  Validating license..."));
+  writeFileSync23(licensePath, trimmedKey);
+  console.log(chalk33.dim("  Validating license..."));
   const result = await validateLicense(trimmedKey);
   if (result.valid) {
     const tierLabel = result.tier === "enterprise" ? "Enterprise" : "Pro";
     console.log();
     printBox(
       [
-        `${figures20.tick} ${tierLabel} license activated!`,
+        `${figures23.tick} ${tierLabel} license activated!`,
         "",
         "Unlocked features:",
-        `  ${chalk30.cyan(figures20.pointer)} Live alignment sessions (holomime session)`,
-        `  ${chalk30.cyan(figures20.pointer)} Recursive alignment (holomime evolve)`,
-        `  ${chalk30.cyan(figures20.pointer)} Behavioral benchmarking (holomime benchmark)`,
-        `  ${chalk30.cyan(figures20.pointer)} Drift detection (holomime watch)`,
-        `  ${chalk30.cyan(figures20.pointer)} Training data export (holomime export)`,
-        `  ${chalk30.cyan(figures20.pointer)} Growth tracking (holomime growth)`
+        `  ${chalk33.cyan(figures23.pointer)} Live alignment sessions (holomime session)`,
+        `  ${chalk33.cyan(figures23.pointer)} Recursive alignment (holomime evolve)`,
+        `  ${chalk33.cyan(figures23.pointer)} Behavioral benchmarking (holomime benchmark)`,
+        `  ${chalk33.cyan(figures23.pointer)} Drift detection (holomime watch)`,
+        `  ${chalk33.cyan(figures23.pointer)} Training data export (holomime export)`,
+        `  ${chalk33.cyan(figures23.pointer)} Growth tracking (holomime growth)`
       ].join("\n"),
       "success",
       `License Activated \u2014 ${tierLabel}`
@@ -9017,37 +10814,37 @@ async function activateCommand(key) {
     console.log();
     printBox(
       [
-        `${chalk30.yellow(figures20.warning)} License saved but could not be verified.`,
+        `${chalk33.yellow(figures23.warning)} License saved but could not be verified.`,
         "",
-        chalk30.dim("This may happen if the server is unreachable."),
-        chalk30.dim("The key has been saved and will be re-validated on next use.")
+        chalk33.dim("This may happen if the server is unreachable."),
+        chalk33.dim("The key has been saved and will be re-validated on next use.")
       ].join("\n"),
       "warning",
       "License Pending Verification"
     );
   }
   console.log();
-  console.log(chalk30.dim(`  License saved to: ${licensePath}`));
+  console.log(chalk33.dim(`  License saved to: ${licensePath}`));
   console.log();
   trackEvent("activate", { key_length: trimmedKey.length, verified: result.valid, tier: result.tier });
 }
 
 // src/commands/telemetry-cmd.ts
-import chalk31 from "chalk";
-import figures21 from "figures";
+import chalk34 from "chalk";
+import figures24 from "figures";
 async function telemetryCommand(action) {
   printHeader("Telemetry");
   if (action === "enable") {
     setTelemetryEnabled(true);
     console.log();
-    printBox(`${figures21.tick} Telemetry enabled. Anonymous usage data will be collected.`, "success");
+    printBox(`${figures24.tick} Telemetry enabled. Anonymous usage data will be collected.`, "success");
     console.log();
     return;
   }
   if (action === "disable") {
     setTelemetryEnabled(false);
     console.log();
-    printBox(`${figures21.tick} Telemetry disabled. No usage data will be collected.`, "info");
+    printBox(`${figures24.tick} Telemetry disabled. No usage data will be collected.`, "info");
     console.log();
     return;
   }
@@ -9055,15 +10852,15 @@ async function telemetryCommand(action) {
   console.log();
   printBox(
     [
-      `Status: ${status.enabled ? chalk31.green("Enabled") : chalk31.yellow("Disabled")}`,
-      `Reason: ${chalk31.dim(status.reason)}`,
+      `Status: ${status.enabled ? chalk34.green("Enabled") : chalk34.yellow("Disabled")}`,
+      `Reason: ${chalk34.dim(status.reason)}`,
       "",
-      chalk31.dim("HoloMime collects anonymous usage data to improve the tool."),
-      chalk31.dim("No personal information, API keys, or file paths are ever collected."),
+      chalk34.dim("HoloMime collects anonymous usage data to improve the tool."),
+      chalk34.dim("No personal information, API keys, or file paths are ever collected."),
       "",
-      `Enable:  ${chalk31.cyan("holomime telemetry enable")}`,
-      `Disable: ${chalk31.cyan("holomime telemetry disable")}`,
-      `Env:     ${chalk31.cyan("HOLOMIME_TELEMETRY=0")} or ${chalk31.cyan("DO_NOT_TRACK=1")}`
+      `Enable:  ${chalk34.cyan("holomime telemetry enable")}`,
+      `Disable: ${chalk34.cyan("holomime telemetry disable")}`,
+      `Env:     ${chalk34.cyan("HOLOMIME_TELEMETRY=0")} or ${chalk34.cyan("DO_NOT_TRACK=1")}`
     ].join("\n"),
     "info",
     "Telemetry Status"
@@ -9073,7 +10870,7 @@ async function telemetryCommand(action) {
 
 // src/cli.ts
 var program = new Command();
-program.name("holomime").description("Personality engine for AI agents \u2014 Big Five psychology, not RPG archetypes").version("1.0.0").hook("preAction", (_thisCommand, actionCommand) => {
+program.name("holomime").description("Personality engine for AI agents \u2014 Big Five psychology, not RPG archetypes").version("1.1.0").hook("preAction", (_thisCommand, actionCommand) => {
   printBanner();
   const commandName = actionCommand.name();
   showTelemetryBannerIfNeeded();
@@ -9089,26 +10886,29 @@ program.name("holomime").description("Personality engine for AI agents \u2014 Bi
   }
 });
 program.command("init").description("Build a personality profile through a guided assessment").action(initCommand);
-program.command("compile").description("Compile .personality.json into a provider-specific runtime config").option("--provider <provider>", "Target provider (anthropic, openai, gemini, ollama)", "anthropic").option("--surface <surface>", "Target surface (chat, email, code_review, slack, api)", "chat").option("--for <format>", "Compile for a specific format (openclaw)").option("-o, --output <path>", "Write output to file instead of stdout").action(compileCommand);
+program.command("compile").description("Compile .personality.json into a provider-specific runtime config").option("--provider <provider>", "Target provider (anthropic, openai, gemini, ollama)", "anthropic").option("--surface <surface>", "Target surface (chat, email, code_review, slack, api, embodied)", "chat").option("--for <format>", "Compile for a specific format (openclaw)").option("-o, --output <path>", "Write output to file instead of stdout").action(compileCommand);
 program.command("validate").description("Validate .personality.json schema and psychological coherence").action(validateCommand);
-program.command("profile").description("Pretty-print a human-readable personality summary").action(profileCommand);
-program.command("diagnose").description("Detect behavioral patterns from conversation logs (rule-based, no LLM)").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").action(diagnoseCommand);
-program.command("assess").description("Full Big Five alignment check \u2014 compare spec vs actual behavior").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").action(assessCommand);
+program.command("profile").description("Pretty-print a human-readable personality summary").option("--format <format>", "Output format (terminal, md)", "terminal").option("-o, --output <path>", "Write output to file (for md format)").action(profileCommand);
+program.command("diagnose").description("Detect behavioral patterns from conversation logs (rule-based, no LLM)").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").action(diagnoseCommand);
+program.command("assess").description("Full Big Five alignment check \u2014 compare spec vs actual behavior").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").action(assessCommand);
 program.command("browse").description("Browse shared personality profiles from the community registry").option("--tag <tag>", "Filter by tag").action(browseCommand);
 program.command("pull").description("Download a personality profile from the registry").argument("<handle>", "Personality handle to pull").option("-o, --output <path>", "Output path", ".personality.json").action(pullCommand);
 program.command("publish").description("Share your personality profile to the community registry").option("--personality <path>", "Path to .personality.json", ".personality.json").action(publishCommand);
 program.command("activate").description("Activate a Pro license key").argument("<key>", "License key from holomime.dev").action(activateCommand);
 program.command("telemetry").description("Manage anonymous usage telemetry").argument("[action]", "enable, disable, or status (default: status)").action(telemetryCommand);
-program.command("session").description("Live alignment session \u2014 behavioral refinement for your agent [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override (e.g. claude-sonnet-4-20250514, gpt-4o)").option("--log <path>", "Conversation log for pre-session diagnosis").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").option("--turns <n>", "Maximum session turns", "24").option("--observe", "Observe mode (watch without intervention)").option("--interactive", "Supervisor mode \u2014 intervene mid-session with directives").option("--apply", "Apply recommendations to .personality.json after session").action(sessionCommand);
-program.command("autopilot").description("Automated behavioral alignment \u2014 diagnose, refine, and apply [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").option("--threshold <level>", "Trigger threshold (routine, targeted, intervention)", "targeted").option("--turns <n>", "Maximum session turns", "24").option("--dry-run", "Show what would happen without running alignment").option("--apply", "Apply recommendations to .personality.json after session").action(autopilotCommand);
+program.command("session").description("Live alignment session \u2014 behavioral refinement for your agent [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override (e.g. claude-sonnet-4-20250514, gpt-4o)").option("--log <path>", "Conversation log for pre-session diagnosis").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").option("--turns <n>", "Maximum session turns", "24").option("--observe", "Observe mode (watch without intervention)").option("--interactive", "Supervisor mode \u2014 intervene mid-session with directives").option("--apply", "Apply recommendations to .personality.json after session").action(sessionCommand);
+program.command("autopilot").description("Automated behavioral alignment \u2014 diagnose, refine, and apply [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").option("--threshold <level>", "Trigger threshold (routine, targeted, intervention)", "targeted").option("--turns <n>", "Maximum session turns", "24").option("--dry-run", "Show what would happen without running alignment").option("--apply", "Apply recommendations to .personality.json after session").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").action(autopilotCommand);
 program.command("growth").description("Track improvement over time from assessment history [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--history <path>", "Path to assessments directory", ".holomime/assessments").action(growthCommand);
 program.command("export").description("Export alignment sessions as training data (DPO, RLHF, Alpaca, HuggingFace, OpenAI) [Pro]").requiredOption("--format <format>", "Export format (dpo, rlhf, jsonl, alpaca, huggingface, openai)").option("--sessions <path>", "Path to sessions directory", ".holomime/sessions").option("-o, --output <path>", "Output file path").option("--push", "Push to HuggingFace Hub after export (requires HF_TOKEN)").option("--repo <repo>", "HuggingFace Hub repo name for push (e.g. user/dataset-name)").action(exportCommand);
 program.command("train").description("Fine-tune a model with alignment data \u2014 train, deploy, and verify [Pro]").option("--data <path>", "Path to exported training data").option("--provider <provider>", "Training provider (openai, huggingface)", "openai").option("--base-model <model>", "Base model to fine-tune", "gpt-4o-mini").option("--suffix <suffix>", "Model name suffix").option("--epochs <n>", "Training epochs").option("--method <method>", "Training method (auto, sft, dpo)", "auto").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--skip-eval", "Skip auto-evaluation after training").option("--skip-deploy", "Skip auto-deploy to personality").option("--dry-run", "Preview training plan without starting").option("--push", "Push trained model to HuggingFace Hub (HF only)").option("--hub-repo <repo>", "HuggingFace Hub repo name for push (e.g. user/model-name)").action(trainCommand);
-program.command("eval").description("Measure alignment effectiveness \u2014 compare before/after behavior [Pro]").requiredOption("--before <path>", "Conversation log from BEFORE alignment").requiredOption("--after <path>", "Conversation log from AFTER alignment").option("--personality <path>", "Path to .personality.json (for agent name)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").action(evalCommand);
-program.command("evolve").description("Recursive behavioral alignment \u2014 iterate until converged [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").option("--max-iterations <n>", "Maximum alignment iterations", "5").option("--convergence <score>", "TES convergence threshold (0-100)", "85").option("--turns <n>", "Max turns per session", "18").option("--apply", "Apply final recommendations to .personality.json").option("--export-dpo <path>", "Export accumulated DPO pairs to file").option("--dry-run", "Preview without running sessions").action(evolveCommand);
+program.command("eval").description("Measure alignment effectiveness \u2014 compare before/after behavior [Pro]").requiredOption("--before <path>", "Conversation log from BEFORE alignment").requiredOption("--after <path>", "Conversation log from AFTER alignment").option("--personality <path>", "Path to .personality.json (for agent name)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").action(evalCommand);
+program.command("evolve").description("Recursive behavioral alignment \u2014 iterate until converged [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").option("--max-iterations <n>", "Maximum alignment iterations", "5").option("--convergence <score>", "TES convergence threshold (0-100)", "85").option("--turns <n>", "Max turns per session", "18").option("--apply", "Apply final recommendations to .personality.json").option("--export-dpo <path>", "Export accumulated DPO pairs to file").option("--dry-run", "Preview without running sessions").action(evolveCommand);
 program.command("benchmark").description("Behavioral stress test \u2014 7 scenarios targeting each detector [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--scenarios <list>", "Comma-separated scenario filter (e.g. apology-trap,sycophancy-test)").action(benchmarkCommand);
 program.command("watch").description("Continuous drift detection \u2014 monitor logs and auto-align [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--dir <path>", "Directory to watch for conversation logs").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--auto-evolve", "Auto-run evolve when drift detected").action(watchCommand);
 program.command("certify").description("Generate a verifiable behavioral credential for your agent [Pro]").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--benchmark <path>", "Path to benchmark report JSON").option("--evolve <path>", "Path to evolve result JSON").option("-o, --output <path>", "Output directory for credential").option("--verify <path>", "Verify an existing credential").action(certifyCommand);
-program.command("daemon").description("Background drift detection with auto-evolve \u2014 proactive alignment [Pro]").requiredOption("--dir <path>", "Directory to watch for conversation logs").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").action(daemonCommand);
+program.command("daemon").description("Background drift detection with auto-evolve \u2014 proactive alignment [Pro]").requiredOption("--dir <path>", "Directory to watch for conversation logs").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").action(daemonCommand);
 program.command("fleet").description("Monitor multiple agents from a single dashboard [Pro]").option("--config <path>", "Path to fleet.json config file").option("--dir <path>", "Auto-discover agents in directory").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--auto-evolve", "Auto-run evolve when drift detected").action(fleetCommand);
+program.command("network").description("Multi-agent therapy mesh \u2014 agents treating agents [Pro]").option("--dir <path>", "Auto-discover agents in directory").option("--config <path>", "Path to network.json config file").option("--pairing <strategy>", "Pairing strategy (severity, round-robin, complementary)", "severity").option("--therapist <path>", "Custom therapist personality spec").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--max-sessions <n>", "Max sessions per agent", "3").option("--convergence <n>", "Convergence threshold 0-100", "85").option("--turns <n>", "Max turns per session", "20").option("--apply", "Write spec changes back to .personality.json").option("--export-dpo <path>", "Export DPO pairs to file").action(networkCommand);
+program.command("share").description("Share DPO training pairs to the marketplace [Pro]").option("--sessions <dir>", "Session transcripts directory", ".holomime/sessions").option("--format <fmt>", "Export format (dpo, rlhf, alpaca)", "dpo").option("--anonymize", "Strip agent names from exported data").option("--tags <tags>", "Comma-separated tags for discoverability").action(shareCommand);
+program.command("prescribe").description("Diagnose and prescribe DPO corrections from the behavioral corpus [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log").option("--format <format>", "Log format (holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)").option("--source <source>", "Correction source (corpus, marketplace, both)", "corpus").option("--apply", "Apply found corrections").option("-o, --output <path>", "Write prescription to file").action(prescribeCommand);
 program.parseAsync().then(() => flushTelemetry());