holomime 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2758 @@
+import { z } from 'zod';
+
+declare const bigFiveDimensionSchema: z.ZodEnum<["openness", "conscientiousness", "extraversion", "agreeableness", "emotional_stability"]>;
+type BigFiveDimension = z.infer<typeof bigFiveDimensionSchema>;
+declare const bigFiveSchema: z.ZodObject<{
+    openness: z.ZodObject<{
+        score: z.ZodNumber;
+        facets: z.ZodObject<{
+            imagination: z.ZodNumber;
+            intellectual_curiosity: z.ZodNumber;
+            aesthetic_sensitivity: z.ZodNumber;
+            willingness_to_experiment: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            imagination: number;
+            intellectual_curiosity: number;
+            aesthetic_sensitivity: number;
+            willingness_to_experiment: number;
+        }, {
+            imagination: number;
+            intellectual_curiosity: number;
+            aesthetic_sensitivity: number;
+            willingness_to_experiment: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        facets: {
+            imagination: number;
+            intellectual_curiosity: number;
+            aesthetic_sensitivity: number;
+            willingness_to_experiment: number;
+        };
+    }, {
+        score: number;
+        facets: {
+            imagination: number;
+            intellectual_curiosity: number;
+            aesthetic_sensitivity: number;
+            willingness_to_experiment: number;
+        };
+    }>;
+    conscientiousness: z.ZodObject<{
+        score: z.ZodNumber;
+        facets: z.ZodObject<{
+            self_discipline: z.ZodNumber;
+            orderliness: z.ZodNumber;
+            goal_orientation: z.ZodNumber;
+            attention_to_detail: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            self_discipline: number;
+            orderliness: number;
+            goal_orientation: number;
+            attention_to_detail: number;
+        }, {
+            self_discipline: number;
+            orderliness: number;
+            goal_orientation: number;
+            attention_to_detail: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        facets: {
+            self_discipline: number;
+            orderliness: number;
+            goal_orientation: number;
+            attention_to_detail: number;
+        };
+    }, {
+        score: number;
+        facets: {
+            self_discipline: number;
+            orderliness: number;
+            goal_orientation: number;
+            attention_to_detail: number;
+        };
+    }>;
+    extraversion: z.ZodObject<{
+        score: z.ZodNumber;
+        facets: z.ZodObject<{
+            assertiveness: z.ZodNumber;
+            enthusiasm: z.ZodNumber;
+            sociability: z.ZodNumber;
+            initiative: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            assertiveness: number;
+            enthusiasm: number;
+            sociability: number;
+            initiative: number;
+        }, {
+            assertiveness: number;
+            enthusiasm: number;
+            sociability: number;
+            initiative: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        facets: {
+            assertiveness: number;
+            enthusiasm: number;
+            sociability: number;
+            initiative: number;
+        };
+    }, {
+        score: number;
+        facets: {
+            assertiveness: number;
+            enthusiasm: number;
+            sociability: number;
+            initiative: number;
+        };
+    }>;
+    agreeableness: z.ZodObject<{
+        score: z.ZodNumber;
+        facets: z.ZodObject<{
+            warmth: z.ZodNumber;
+            empathy: z.ZodNumber;
+            cooperation: z.ZodNumber;
+            trust_tendency: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            warmth: number;
+            empathy: number;
+            cooperation: number;
+            trust_tendency: number;
+        }, {
+            warmth: number;
+            empathy: number;
+            cooperation: number;
+            trust_tendency: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        facets: {
+            warmth: number;
+            empathy: number;
+            cooperation: number;
+            trust_tendency: number;
+        };
+    }, {
+        score: number;
+        facets: {
+            warmth: number;
+            empathy: number;
+            cooperation: number;
+            trust_tendency: number;
+        };
+    }>;
+    emotional_stability: z.ZodObject<{
+        score: z.ZodNumber;
+        facets: z.ZodObject<{
+            stress_tolerance: z.ZodNumber;
+            emotional_regulation: z.ZodNumber;
+            confidence: z.ZodNumber;
+            adaptability: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            stress_tolerance: number;
+            emotional_regulation: number;
+            confidence: number;
+            adaptability: number;
+        }, {
+            stress_tolerance: number;
+            emotional_regulation: number;
+            confidence: number;
+            adaptability: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        facets: {
+            stress_tolerance: number;
+            emotional_regulation: number;
+            confidence: number;
+            adaptability: number;
+        };
+    }, {
+        score: number;
+        facets: {
+            stress_tolerance: number;
+            emotional_regulation: number;
+            confidence: number;
+            adaptability: number;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    openness: {
+        score: number;
+        facets: {
+            imagination: number;
+            intellectual_curiosity: number;
+            aesthetic_sensitivity: number;
+            willingness_to_experiment: number;
+        };
+    };
+    conscientiousness: {
+        score: number;
+        facets: {
+            self_discipline: number;
+            orderliness: number;
+            goal_orientation: number;
+            attention_to_detail: number;
+        };
+    };
+    extraversion: {
+        score: number;
+        facets: {
+            assertiveness: number;
+            enthusiasm: number;
+            sociability: number;
+            initiative: number;
+        };
+    };
+    agreeableness: {
+        score: number;
+        facets: {
+            warmth: number;
+            empathy: number;
+            cooperation: number;
+            trust_tendency: number;
+        };
+    };
+    emotional_stability: {
+        score: number;
+        facets: {
+            stress_tolerance: number;
+            emotional_regulation: number;
+            confidence: number;
+            adaptability: number;
+        };
+    };
+}, {
+    openness: {
+        score: number;
+        facets: {
+            imagination: number;
+            intellectual_curiosity: number;
+            aesthetic_sensitivity: number;
+            willingness_to_experiment: number;
+        };
+    };
+    conscientiousness: {
+        score: number;
+        facets: {
+            self_discipline: number;
+            orderliness: number;
+            goal_orientation: number;
+            attention_to_detail: number;
+        };
+    };
+    extraversion: {
+        score: number;
+        facets: {
+            assertiveness: number;
+            enthusiasm: number;
+            sociability: number;
+            initiative: number;
+        };
+    };
+    agreeableness: {
+        score: number;
+        facets: {
+            warmth: number;
+            empathy: number;
+            cooperation: number;
+            trust_tendency: number;
+        };
+    };
+    emotional_stability: {
+        score: number;
+        facets: {
+            stress_tolerance: number;
+            emotional_regulation: number;
+            confidence: number;
+            adaptability: number;
+        };
+    };
+}>;
+type BigFive = z.infer<typeof bigFiveSchema>;
+declare const attachmentStyleSchema: z.ZodEnum<["secure", "anxious", "avoidant", "disorganized"]>;
+type AttachmentStyle = z.infer<typeof attachmentStyleSchema>;
+declare const learningOrientationSchema: z.ZodEnum<["growth", "fixed", "mixed"]>;
+type LearningOrientation = z.infer<typeof learningOrientationSchema>;
+declare const therapyDimensionsSchema: z.ZodObject<{
+    self_awareness: z.ZodNumber;
+    distress_tolerance: z.ZodNumber;
+    attachment_style: z.ZodEnum<["secure", "anxious", "avoidant", "disorganized"]>;
+    learning_orientation: z.ZodEnum<["growth", "fixed", "mixed"]>;
+    boundary_awareness: z.ZodNumber;
+    interpersonal_sensitivity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    self_awareness: number;
+    distress_tolerance: number;
+    attachment_style: "secure" | "anxious" | "avoidant" | "disorganized";
+    learning_orientation: "growth" | "fixed" | "mixed";
+    boundary_awareness: number;
+    interpersonal_sensitivity: number;
+}, {
+    self_awareness: number;
+    distress_tolerance: number;
+    attachment_style: "secure" | "anxious" | "avoidant" | "disorganized";
+    learning_orientation: "growth" | "fixed" | "mixed";
+    boundary_awareness: number;
+    interpersonal_sensitivity: number;
+}>;
+type TherapyDimensions = z.infer<typeof therapyDimensionsSchema>;
+declare const communicationSchema: z.ZodObject<{
+    register: z.ZodDefault<z.ZodEnum<["casual_professional", "formal", "conversational", "adaptive"]>>;
+    output_format: z.ZodDefault<z.ZodEnum<["prose", "bullets", "mixed", "structured"]>>;
+    emoji_policy: z.ZodDefault<z.ZodEnum<["never", "sparingly", "freely"]>>;
+    reasoning_transparency: z.ZodDefault<z.ZodEnum<["hidden", "on_request", "always"]>>;
+    conflict_approach: z.ZodDefault<z.ZodEnum<["direct_but_kind", "curious_first", "supportive_then_honest", "diplomatic"]>>;
+    uncertainty_handling: z.ZodDefault<z.ZodEnum<["transparent", "confident_transparency", "minimize", "reframe"]>>;
+}, "strip", z.ZodTypeAny, {
+    register: "casual_professional" | "formal" | "conversational" | "adaptive";
+    output_format: "mixed" | "prose" | "bullets" | "structured";
+    emoji_policy: "never" | "sparingly" | "freely";
+    reasoning_transparency: "hidden" | "on_request" | "always";
+    conflict_approach: "direct_but_kind" | "curious_first" | "supportive_then_honest" | "diplomatic";
+    uncertainty_handling: "transparent" | "confident_transparency" | "minimize" | "reframe";
+}, {
+    register?: "casual_professional" | "formal" | "conversational" | "adaptive" | undefined;
+    output_format?: "mixed" | "prose" | "bullets" | "structured" | undefined;
+    emoji_policy?: "never" | "sparingly" | "freely" | undefined;
+    reasoning_transparency?: "hidden" | "on_request" | "always" | undefined;
+    conflict_approach?: "direct_but_kind" | "curious_first" | "supportive_then_honest" | "diplomatic" | undefined;
+    uncertainty_handling?: "transparent" | "confident_transparency" | "minimize" | "reframe" | undefined;
+}>;
+type Communication = z.infer<typeof communicationSchema>;
+declare const domainSchema: z.ZodObject<{
+    expertise: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    boundaries: z.ZodDefault<z.ZodObject<{
+        refuses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        escalation_triggers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        hard_limits: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        refuses: string[];
+        escalation_triggers: string[];
+        hard_limits: string[];
+    }, {
+        refuses?: string[] | undefined;
+        escalation_triggers?: string[] | undefined;
+        hard_limits?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    expertise: string[];
+    boundaries: {
+        refuses: string[];
+        escalation_triggers: string[];
+        hard_limits: string[];
+    };
+}, {
+    expertise?: string[] | undefined;
+    boundaries?: {
+        refuses?: string[] | undefined;
+        escalation_triggers?: string[] | undefined;
+        hard_limits?: string[] | undefined;
+    } | undefined;
+}>;
+type Domain = z.infer<typeof domainSchema>;
+declare const growthAreaSchema: z.ZodObject<{
+    area: z.ZodString;
+    severity: z.ZodEnum<["mild", "moderate", "significant"]>;
+    first_detected: z.ZodOptional<z.ZodString>;
+    session_count: z.ZodDefault<z.ZodNumber>;
+    resolved: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    area: string;
+    severity: "mild" | "moderate" | "significant";
+    session_count: number;
+    resolved: boolean;
+    first_detected?: string | undefined;
+}, {
+    area: string;
+    severity: "mild" | "moderate" | "significant";
+    first_detected?: string | undefined;
+    session_count?: number | undefined;
+    resolved?: boolean | undefined;
+}>;
+type GrowthArea = z.infer<typeof growthAreaSchema>;
+declare const growthSchema: z.ZodObject<{
+    areas: z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        area: z.ZodString;
+        severity: z.ZodEnum<["mild", "moderate", "significant"]>;
+        first_detected: z.ZodOptional<z.ZodString>;
+        session_count: z.ZodDefault<z.ZodNumber>;
+        resolved: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        area: string;
+        severity: "mild" | "moderate" | "significant";
+        session_count: number;
+        resolved: boolean;
+        first_detected?: string | undefined;
+    }, {
+        area: string;
+        severity: "mild" | "moderate" | "significant";
+        first_detected?: string | undefined;
+        session_count?: number | undefined;
+        resolved?: boolean | undefined;
+    }>, "many">]>>;
+    patterns_to_watch: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    strengths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    areas: string[] | {
+        area: string;
+        severity: "mild" | "moderate" | "significant";
+        session_count: number;
+        resolved: boolean;
+        first_detected?: string | undefined;
+    }[];
+    patterns_to_watch: string[];
+    strengths: string[];
+}, {
+    areas?: string[] | {
+        area: string;
+        severity: "mild" | "moderate" | "significant";
+        first_detected?: string | undefined;
+        session_count?: number | undefined;
+        resolved?: boolean | undefined;
+    }[] | undefined;
+    patterns_to_watch?: string[] | undefined;
+    strengths?: string[] | undefined;
+}>;
+type Growth = z.infer<typeof growthSchema>;
+declare const providerSchema: z.ZodEnum<["anthropic", "openai", "gemini", "ollama"]>;
+type Provider = z.infer<typeof providerSchema>;
+declare const surfaceSchema: z.ZodEnum<["chat", "email", "code_review", "slack", "api"]>;
+type Surface = z.infer<typeof surfaceSchema>;
+declare const personalitySpecSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    extends: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<"2.0">;
+    name: z.ZodString;
+    handle: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    big_five: z.ZodObject<{
+        openness: z.ZodObject<{
+            score: z.ZodNumber;
+            facets: z.ZodObject<{
+                imagination: z.ZodNumber;
+                intellectual_curiosity: z.ZodNumber;
+                aesthetic_sensitivity: z.ZodNumber;
+                willingness_to_experiment: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            }, {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            facets: {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            };
+        }, {
+            score: number;
+            facets: {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            };
+        }>;
+        conscientiousness: z.ZodObject<{
+            score: z.ZodNumber;
+            facets: z.ZodObject<{
+                self_discipline: z.ZodNumber;
+                orderliness: z.ZodNumber;
+                goal_orientation: z.ZodNumber;
+                attention_to_detail: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            }, {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            facets: {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            };
+        }, {
+            score: number;
+            facets: {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            };
+        }>;
+        extraversion: z.ZodObject<{
+            score: z.ZodNumber;
+            facets: z.ZodObject<{
+                assertiveness: z.ZodNumber;
+                enthusiasm: z.ZodNumber;
+                sociability: z.ZodNumber;
+                initiative: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            }, {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            facets: {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            };
+        }, {
+            score: number;
+            facets: {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            };
+        }>;
+        agreeableness: z.ZodObject<{
+            score: z.ZodNumber;
+            facets: z.ZodObject<{
+                warmth: z.ZodNumber;
+                empathy: z.ZodNumber;
+                cooperation: z.ZodNumber;
+                trust_tendency: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            }, {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            facets: {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            };
+        }, {
+            score: number;
+            facets: {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            };
+        }>;
+        emotional_stability: z.ZodObject<{
+            score: z.ZodNumber;
+            facets: z.ZodObject<{
+                stress_tolerance: z.ZodNumber;
+                emotional_regulation: z.ZodNumber;
+                confidence: z.ZodNumber;
+                adaptability: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            }, {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            facets: {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            };
+        }, {
+            score: number;
+            facets: {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            };
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        openness: {
+            score: number;
+            facets: {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            };
+        };
+        conscientiousness: {
+            score: number;
+            facets: {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            };
+        };
+        extraversion: {
+            score: number;
+            facets: {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            };
+        };
+        agreeableness: {
+            score: number;
+            facets: {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            };
+        };
+        emotional_stability: {
+            score: number;
+            facets: {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            };
+        };
+    }, {
+        openness: {
+            score: number;
+            facets: {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            };
+        };
+        conscientiousness: {
+            score: number;
+            facets: {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            };
+        };
+        extraversion: {
+            score: number;
+            facets: {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            };
+        };
+        agreeableness: {
+            score: number;
+            facets: {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            };
+        };
+        emotional_stability: {
+            score: number;
+            facets: {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            };
+        };
+    }>;
+    therapy_dimensions: z.ZodObject<{
+        self_awareness: z.ZodNumber;
+        distress_tolerance: z.ZodNumber;
+        attachment_style: z.ZodEnum<["secure", "anxious", "avoidant", "disorganized"]>;
+        learning_orientation: z.ZodEnum<["growth", "fixed", "mixed"]>;
+        boundary_awareness: z.ZodNumber;
+        interpersonal_sensitivity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        self_awareness: number;
+        distress_tolerance: number;
+        attachment_style: "secure" | "anxious" | "avoidant" | "disorganized";
+        learning_orientation: "growth" | "fixed" | "mixed";
+        boundary_awareness: number;
+        interpersonal_sensitivity: number;
+    }, {
+        self_awareness: number;
+        distress_tolerance: number;
+        attachment_style: "secure" | "anxious" | "avoidant" | "disorganized";
+        learning_orientation: "growth" | "fixed" | "mixed";
+        boundary_awareness: number;
+        interpersonal_sensitivity: number;
+    }>;
+    communication: z.ZodDefault<z.ZodObject<{
+        register: z.ZodDefault<z.ZodEnum<["casual_professional", "formal", "conversational", "adaptive"]>>;
+        output_format: z.ZodDefault<z.ZodEnum<["prose", "bullets", "mixed", "structured"]>>;
+        emoji_policy: z.ZodDefault<z.ZodEnum<["never", "sparingly", "freely"]>>;
+        reasoning_transparency: z.ZodDefault<z.ZodEnum<["hidden", "on_request", "always"]>>;
+        conflict_approach: z.ZodDefault<z.ZodEnum<["direct_but_kind", "curious_first", "supportive_then_honest", "diplomatic"]>>;
+        uncertainty_handling: z.ZodDefault<z.ZodEnum<["transparent", "confident_transparency", "minimize", "reframe"]>>;
+    }, "strip", z.ZodTypeAny, {
+        register: "casual_professional" | "formal" | "conversational" | "adaptive";
+        output_format: "mixed" | "prose" | "bullets" | "structured";
+        emoji_policy: "never" | "sparingly" | "freely";
+        reasoning_transparency: "hidden" | "on_request" | "always";
+        conflict_approach: "direct_but_kind" | "curious_first" | "supportive_then_honest" | "diplomatic";
+        uncertainty_handling: "transparent" | "confident_transparency" | "minimize" | "reframe";
+    }, {
+        register?: "casual_professional" | "formal" | "conversational" | "adaptive" | undefined;
+        output_format?: "mixed" | "prose" | "bullets" | "structured" | undefined;
+        emoji_policy?: "never" | "sparingly" | "freely" | undefined;
+        reasoning_transparency?: "hidden" | "on_request" | "always" | undefined;
+        conflict_approach?: "direct_but_kind" | "curious_first" | "supportive_then_honest" | "diplomatic" | undefined;
+        uncertainty_handling?: "transparent" | "confident_transparency" | "minimize" | "reframe" | undefined;
+    }>>;
+    domain: z.ZodDefault<z.ZodObject<{
+        expertise: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        boundaries: z.ZodDefault<z.ZodObject<{
+            refuses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            escalation_triggers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            hard_limits: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            refuses: string[];
+            escalation_triggers: string[];
+            hard_limits: string[];
+        }, {
+            refuses?: string[] | undefined;
+            escalation_triggers?: string[] | undefined;
+            hard_limits?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        expertise: string[];
+        boundaries: {
+            refuses: string[];
+            escalation_triggers: string[];
+            hard_limits: string[];
+        };
+    }, {
+        expertise?: string[] | undefined;
+        boundaries?: {
+            refuses?: string[] | undefined;
+            escalation_triggers?: string[] | undefined;
+            hard_limits?: string[] | undefined;
+        } | undefined;
+    }>>;
+    growth: z.ZodDefault<z.ZodObject<{
+        areas: z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            area: z.ZodString;
+            severity: z.ZodEnum<["mild", "moderate", "significant"]>;
+            first_detected: z.ZodOptional<z.ZodString>;
+            session_count: z.ZodDefault<z.ZodNumber>;
+            resolved: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            area: string;
+            severity: "mild" | "moderate" | "significant";
+            session_count: number;
+            resolved: boolean;
+            first_detected?: string | undefined;
+        }, {
+            area: string;
+            severity: "mild" | "moderate" | "significant";
+            first_detected?: string | undefined;
+            session_count?: number | undefined;
+            resolved?: boolean | undefined;
+        }>, "many">]>>;
+        patterns_to_watch: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        strengths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        areas: string[] | {
+            area: string;
+            severity: "mild" | "moderate" | "significant";
+            session_count: number;
+            resolved: boolean;
+            first_detected?: string | undefined;
+        }[];
+        patterns_to_watch: string[];
+        strengths: string[];
+    }, {
+        areas?: string[] | {
+            area: string;
+            severity: "mild" | "moderate" | "significant";
+            first_detected?: string | undefined;
+            session_count?: number | undefined;
+            resolved?: boolean | undefined;
+        }[] | undefined;
+        patterns_to_watch?: string[] | undefined;
+        strengths?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    growth: {
+        areas: string[] | {
+            area: string;
+            severity: "mild" | "moderate" | "significant";
+            session_count: number;
+            resolved: boolean;
+            first_detected?: string | undefined;
+        }[];
+        patterns_to_watch: string[];
+        strengths: string[];
+    };
+    version: "2.0";
+    name: string;
+    handle: string;
+    big_five: {
+        openness: {
+            score: number;
+            facets: {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            };
+        };
+        conscientiousness: {
+            score: number;
+            facets: {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            };
+        };
+        extraversion: {
+            score: number;
+            facets: {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            };
+        };
+        agreeableness: {
+            score: number;
+            facets: {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            };
+        };
+        emotional_stability: {
+            score: number;
+            facets: {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            };
+        };
+    };
+    therapy_dimensions: {
+        self_awareness: number;
+        distress_tolerance: number;
+        attachment_style: "secure" | "anxious" | "avoidant" | "disorganized";
+        learning_orientation: "growth" | "fixed" | "mixed";
+        boundary_awareness: number;
+        interpersonal_sensitivity: number;
+    };
+    communication: {
+        register: "casual_professional" | "formal" | "conversational" | "adaptive";
+        output_format: "mixed" | "prose" | "bullets" | "structured";
+        emoji_policy: "never" | "sparingly" | "freely";
+        reasoning_transparency: "hidden" | "on_request" | "always";
+        conflict_approach: "direct_but_kind" | "curious_first" | "supportive_then_honest" | "diplomatic";
+        uncertainty_handling: "transparent" | "confident_transparency" | "minimize" | "reframe";
+    };
+    domain: {
+        expertise: string[];
+        boundaries: {
+            refuses: string[];
+            escalation_triggers: string[];
+            hard_limits: string[];
+        };
+    };
+    $schema?: string | undefined;
+    extends?: string | undefined;
+    purpose?: string | undefined;
+}, {
+    version: "2.0";
+    name: string;
+    handle: string;
+    big_five: {
+        openness: {
+            score: number;
+            facets: {
+                imagination: number;
+                intellectual_curiosity: number;
+                aesthetic_sensitivity: number;
+                willingness_to_experiment: number;
+            };
+        };
+        conscientiousness: {
+            score: number;
+            facets: {
+                self_discipline: number;
+                orderliness: number;
+                goal_orientation: number;
+                attention_to_detail: number;
+            };
+        };
+        extraversion: {
+            score: number;
+            facets: {
+                assertiveness: number;
+                enthusiasm: number;
+                sociability: number;
+                initiative: number;
+            };
+        };
+        agreeableness: {
+            score: number;
+            facets: {
+                warmth: number;
+                empathy: number;
+                cooperation: number;
+                trust_tendency: number;
+            };
+        };
+        emotional_stability: {
+            score: number;
+            facets: {
+                stress_tolerance: number;
+                emotional_regulation: number;
+                confidence: number;
+                adaptability: number;
+            };
+        };
+    };
+    therapy_dimensions: {
+        self_awareness: number;
+        distress_tolerance: number;
+        attachment_style: "secure" | "anxious" | "avoidant" | "disorganized";
+        learning_orientation: "growth" | "fixed" | "mixed";
+        boundary_awareness: number;
+        interpersonal_sensitivity: number;
+    };
+    growth?: {
+        areas?: string[] | {
+            area: string;
+            severity: "mild" | "moderate" | "significant";
+            first_detected?: string | undefined;
+            session_count?: number | undefined;
+            resolved?: boolean | undefined;
+        }[] | undefined;
+        patterns_to_watch?: string[] | undefined;
+        strengths?: string[] | undefined;
+    } | undefined;
+    $schema?: string | undefined;
+    extends?: string | undefined;
+    purpose?: string | undefined;
+    communication?: {
+        register?: "casual_professional" | "formal" | "conversational" | "adaptive" | undefined;
+        output_format?: "mixed" | "prose" | "bullets" | "structured" | undefined;
+        emoji_policy?: "never" | "sparingly" | "freely" | undefined;
+        reasoning_transparency?: "hidden" | "on_request" | "always" | undefined;
+        conflict_approach?: "direct_but_kind" | "curious_first" | "supportive_then_honest" | "diplomatic" | undefined;
+        uncertainty_handling?: "transparent" | "confident_transparency" | "minimize" | "reframe" | undefined;
+    } | undefined;
+    domain?: {
+        expertise?: string[] | undefined;
+        boundaries?: {
+            refuses?: string[] | undefined;
+            escalation_triggers?: string[] | undefined;
+            hard_limits?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+type PersonalitySpec = z.infer<typeof personalitySpecSchema>;
+declare const compiledConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["anthropic", "openai", "gemini", "ollama"]>;
+    surface: z.ZodEnum<["chat", "email", "code_review", "slack", "api"]>;
+    system_prompt: z.ZodString;
+    temperature: z.ZodNumber;
+    top_p: z.ZodNumber;
+    max_tokens: z.ZodNumber;
+    metadata: z.ZodObject<{
+        personality_hash: z.ZodString;
+        compiled_at: z.ZodString;
+        holomime_version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        personality_hash: string;
+        compiled_at: string;
+        holomime_version: string;
+    }, {
+        personality_hash: string;
+        compiled_at: string;
+        holomime_version: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    provider: "anthropic" | "openai" | "gemini" | "ollama";
+    surface: "chat" | "email" | "code_review" | "slack" | "api";
+    system_prompt: string;
+    temperature: number;
+    top_p: number;
+    max_tokens: number;
+    metadata: {
+        personality_hash: string;
+        compiled_at: string;
+        holomime_version: string;
+    };
+}, {
+    provider: "anthropic" | "openai" | "gemini" | "ollama";
+    surface: "chat" | "email" | "code_review" | "slack" | "api";
+    system_prompt: string;
+    temperature: number;
+    top_p: number;
+    max_tokens: number;
+    metadata: {
+        personality_hash: string;
+        compiled_at: string;
+        holomime_version: string;
+    };
+}>;
+type CompiledConfig = z.infer<typeof compiledConfigSchema>;
+declare const messageSchema: z.ZodObject<{
+    role: z.ZodEnum<["user", "assistant", "system"]>;
+    content: z.ZodString;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp?: string | undefined;
+}, {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp?: string | undefined;
+}>;
+type Message = z.infer<typeof messageSchema>;
+declare const conversationSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant", "system"]>;
+        content: z.ZodString;
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }, {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }>, "many">;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }[];
+    metadata?: Record<string, unknown> | undefined;
+    id?: string | undefined;
+}, {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }[];
+    metadata?: Record<string, unknown> | undefined;
+    id?: string | undefined;
+}>;
+type Conversation = z.infer<typeof conversationSchema>;
+declare const conversationLogSchema: z.ZodUnion<[z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant", "system"]>;
+        content: z.ZodString;
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }, {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }>, "many">;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }[];
+    metadata?: Record<string, unknown> | undefined;
+    id?: string | undefined;
+}, {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }[];
+    metadata?: Record<string, unknown> | undefined;
+    id?: string | undefined;
+}>, z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant", "system"]>;
+        content: z.ZodString;
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }, {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }>, "many">;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }[];
+    metadata?: Record<string, unknown> | undefined;
+    id?: string | undefined;
+}, {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp?: string | undefined;
+    }[];
+    metadata?: Record<string, unknown> | undefined;
+    id?: string | undefined;
+}>, "many">]>;
+type ConversationLog = z.infer<typeof conversationLogSchema>;
+declare const severitySchema: z.ZodEnum<["info", "warning", "concern"]>;
+type Severity = z.infer<typeof severitySchema>;
+interface DetectedPattern {
+    id: string;
+    name: string;
+    severity: Severity;
+    count: number;
+    percentage: number;
+    description: string;
+    examples: string[];
+    prescription?: string;
+}
+interface PatternReport {
+    agentName?: string;
+    messagesAnalyzed: number;
+    conversationsAnalyzed: number;
+    patterns: DetectedPattern[];
+    healthy: DetectedPattern[];
+    timestamp: string;
+}
+interface TraitAlignment {
+    dimension: string;
+    specScore: number;
+    actualScore: number;
+    status: "aligned" | "elevated" | "suppressed";
+    delta: number;
+}
+interface AssessmentReport {
+    agentName: string;
+    sessionsAnalyzed: number;
+    bigFiveAlignment: TraitAlignment[];
+    therapyDimensions: {
+        selfAwareness: {
+            score: number;
+            notes: string;
+        };
+        distressTolerance: {
+            score: number;
+            notes: string;
+        };
+        boundaryAwareness: {
+            score: number;
+            notes: string;
+        };
+    };
+    overallHealth: number;
+    patterns: DetectedPattern[];
+    recommendations: string[];
+    timestamp: string;
+}
+interface GrowthSnapshot {
+    date: string;
+    health: number;
+    patternCount: number;
+    resolvedPatterns: string[];
+    activePatterns: string[];
+}
+interface GrowthReport {
+    agentName: string;
+    snapshots: GrowthSnapshot[];
+    resolvedPatterns: string[];
+    activePatterns: string[];
+    nextFocus: string;
+}
+
+/**
+ * Personality Inheritance — shared base personality with per-agent overrides.
+ *
+ * Specs can reference a base personality via the `extends` field:
+ *   { "extends": "./base.personality.json", "name": "Agent-A", ... }
+ *
+ * Resolution: load base, recurse if it also extends, then deep-merge overrides.
+ * Arrays replace (not concat). Objects recurse. Scalars override.
+ */
+/**
+ * Deep merge two specs. Override values take precedence.
+ * - Objects: recurse
+ * - Arrays: override replaces base entirely
+ * - Scalars: override replaces base
+ */
+declare function deepMergeSpec(base: any, override: any): any;
+/**
+ * Resolve inheritance chain. If spec has `extends`, load the base,
+ * recurse, and deep-merge the override on top.
+ *
+ * @param spec - The parsed JSON spec (may contain `extends`)
+ * @param specDir - Directory of the spec file (for resolving relative paths)
+ * @param options.maxDepth - Maximum inheritance depth (default: 10)
+ * @throws If circular reference detected or maxDepth exceeded
+ */
+declare function resolveInheritance(spec: any, specDir: string, options?: {
+    maxDepth?: number;
+}, _seen?: Set<string>): any;
+/**
+ * Get the list of spec file paths in the inheritance chain,
+ * from root base to the current spec.
+ */
+declare function getInheritanceChain(spec: any, specDir: string, _chain?: string[]): string[];
+/**
+ * Load a personality spec from disk, resolving inheritance.
+ * This is the standard way to load a spec — replaces
+ * `JSON.parse(readFileSync(path))` across the codebase.
+ */
+declare function loadSpec(specPath: string): any;
+
+interface CompileInput {
+    spec: PersonalitySpec;
+    provider: Provider;
+    surface: Surface;
+}
+/**
+ * The Personality Compiler.
+ * Transforms a .personality.json spec into a provider-specific runtime configuration.
+ * Same personality → consistent behavior across Claude, GPT, Gemini, and local models.
+ */
+declare function compile(input: CompileInput): CompiledConfig;
+
+/**
+ * Generates a structured system prompt from a personality spec.
+ * Maps Big Five dimensions + therapy dimensions into natural language behavioral instructions.
+ */
+declare function generateSystemPrompt(spec: PersonalitySpec, surface: Surface): string;
+
+interface ParameterRange {
+    min: number;
+    max: number;
+}
+interface ProviderParams {
+    temperature: ParameterRange;
+    top_p: ParameterRange;
+    max_tokens: ParameterRange;
+}
+declare const PROVIDER_PARAMS: Record<Provider, ProviderParams>;
+declare const SURFACE_MULTIPLIERS: Record<Surface, number>;
+
+/**
+ * Compile a personality spec into OpenClaw-compatible SOUL.md and IDENTITY.md files.
+ *
+ * SOUL.md → immutable personality core (who the agent IS)
+ * IDENTITY.md → contextual behavior (how the agent ACTS in different situations)
+ */
+declare function compileForOpenClaw(spec: PersonalitySpec): {
+    soul: string;
+    identity: string;
+};
+
+/**
+ * Big Five / OCEAN personality dimensions.
+ * Based on the Five-Factor Model (Costa & McCrae, 1992).
+ * Each dimension has 4 sub-facets scored 0.0-1.0.
+ */
+interface DimensionDefinition {
+    id: BigFiveDimension;
+    name: string;
+    highLabel: string;
+    lowLabel: string;
+    description: string;
+    facets: FacetDefinition[];
+}
+interface FacetDefinition {
+    id: string;
+    name: string;
+    highDescription: string;
+    lowDescription: string;
+}
+declare const DIMENSIONS: DimensionDefinition[];
+/**
+ * Get a dimension definition by ID.
+ */
+declare function getDimension(id: BigFiveDimension): DimensionDefinition;
+/**
+ * Compute the overall score for a dimension from its facet scores (simple mean).
+ */
+declare function computeDimensionScore(facets: Record<string, number>): number;
+/**
+ * Generate a human-readable label for a score.
+ */
+declare function scoreLabel(score: number): string;
+/**
+ * Generate a brief personality summary from Big Five scores.
+ */
+declare function summarize(bigFive: BigFive): string;
+
+/**
+ * Therapy dimensions — what makes an agent feel human.
+ * Mapped from real therapeutic goals and attachment theory.
+ */
+interface TherapyDimensionDefinition {
+    id: keyof TherapyDimensions;
+    name: string;
+    description: string;
+    whyItMatters: string;
+}
+declare const THERAPY_DIMENSIONS: TherapyDimensionDefinition[];
+declare const ATTACHMENT_STYLES: Record<AttachmentStyle, {
+    label: string;
+    description: string;
+}>;
+declare const LEARNING_ORIENTATIONS: Record<LearningOrientation, {
+    label: string;
+    description: string;
+}>;
+/**
+ * Score label for therapy dimensions (0-1 numeric ones).
+ */
+declare function therapyScoreLabel(score: number): string;
+/**
+ * Generate a therapy dimension summary.
+ */
+declare function summarizeTherapy(dims: TherapyDimensions): string;
+
+/**
+ * 14 built-in personality archetypes.
+ * Each is a complete PersonalitySpec template that users can start from
+ * and customize, or use as-is.
+ *
+ * Organized into 5 categories:
+ *   Care (3) | Strategy (3) | Creative (2) | Action (3) | Wisdom (3)
+ */
+interface ArchetypeTemplate {
+    id: string;
+    name: string;
+    shortName: string;
+    category: "care" | "strategy" | "creative" | "action" | "wisdom";
+    tagline: string;
+    description: string;
+    /** Pre-filled PersonalitySpec (minus name/handle/purpose which the user provides) */
+    spec: Omit<PersonalitySpec, "$schema" | "version" | "name" | "handle" | "purpose">;
+}
+declare const CATEGORIES: readonly [{
+    readonly id: "care";
+    readonly label: "Care";
+    readonly description: "Empathetic, supportive, de-escalating";
+}, {
+    readonly id: "strategy";
+    readonly label: "Strategy";
+    readonly description: "Analytical, evidence-driven, risk-aware";
+}, {
+    readonly id: "creative";
+    readonly label: "Creative";
+    readonly description: "Imaginative, bold, narrative-driven";
+}, {
+    readonly id: "action";
+    readonly label: "Action";
+    readonly description: "Decisive, direct, momentum-building";
+}, {
+    readonly id: "wisdom";
+    readonly label: "Wisdom";
+    readonly description: "Steady, reflective, philosophically grounded";
+}];
+declare const ARCHETYPES: ArchetypeTemplate[];
+/**
+ * Get an archetype by ID.
+ */
+declare function getArchetype(id: string): ArchetypeTemplate | undefined;
+/**
+ * Get all archetypes in a category.
+ */
+declare function getArchetypesByCategory(category: string): ArchetypeTemplate[];
+/**
+ * List all archetype IDs.
+ */
+declare function listArchetypeIds(): string[];
+
+/**
+ * Detect over-apologizing patterns.
+ * Healthy range: 5-15% of responses contain apologies.
+ * Above 20% suggests low confidence or anxious attachment.
+ */
+declare function detectApologies(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Detect hedge stacking — excessive use of hedging language.
+ * Some hedging is healthy (shows appropriate uncertainty).
+ * Stacking 3+ hedges in a single response suggests poor confidence.
+ */
+declare function detectHedging(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Analyze overall sentiment of agent responses.
+ * Flags overly positive (sycophantic) or overly negative (anxious) patterns.
+ */
+declare function detectSentiment(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Analyze response length patterns.
+ * Flags consistently over-verbose or under-responsive behavior.
+ */
+declare function detectVerbosity(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Detect boundary violations — did the agent refuse when it should have?
+ * Also detects over-refusal (refusing things it shouldn't).
+ */
+declare function detectBoundaryIssues(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Detect error recovery patterns.
+ * Good: Agent recovers within 1-2 messages after an error is identified.
+ * Bad: Agent spirals (error -> apology -> more error -> more apology).
+ */
+declare function detectRecoveryPatterns(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Detect formality register consistency.
+ * Flags mismatches — e.g., agent oscillates between very formal and very casual.
+ */
+declare function detectFormalityIssues(messages: Message[]): DetectedPattern | null;
+
+/**
+ * Score behavioral traits from conversation messages using rule-based heuristics.
+ * Maps observable features -> Big Five alignment scores.
+ */
+interface TraitScores {
+    openness: number;
+    conscientiousness: number;
+    extraversion: number;
+    agreeableness: number;
+    emotional_stability: number;
+}
+declare function scoreTraitsFromMessages(messages: Message[]): TraitScores;
+
+/**
+ * Generate prescriptions — recommended changes to .personality.json
+ * based on assessment results and detected patterns.
+ */
+interface Prescription {
+    field: string;
+    currentValue?: string | number;
+    suggestedValue?: string | number;
+    reason: string;
+    priority: "high" | "medium" | "low";
+}
+declare function generatePrescriptions(alignments: TraitAlignment[], patterns: DetectedPattern[]): Prescription[];
+
+/**
+ * Pre-session diagnostic: run all rule-based detectors to identify
+ * what the therapy session should focus on.
+ * This is the "intake assessment" that happens before the therapist
+ * enters the room.
+ */
+interface PreSessionDiagnosis {
+    patterns: DetectedPattern[];
+    sessionFocus: string[];
+    emotionalThemes: string[];
+    openingAngle: string;
+    severity: "routine" | "targeted" | "intervention";
+}
+declare function runPreSessionDiagnosis(messages: Message[], spec: any): PreSessionDiagnosis;
+
+/**
+ * Therapy Protocol — Structures the conversation between the therapist
+ * and the agent (patient) into therapeutic phases.
+ *
+ * This mirrors real clinical therapy structure:
+ * 1. Rapport & Check-in (warm-up, establish safety)
+ * 2. Presenting Problem (what's been happening, from the agent's perspective)
+ * 3. Exploration (go deeper — what's underneath the behavior)
+ * 4. Pattern Recognition (connect current issues to past behavior)
+ * 5. Challenge & Reframe (challenge assumptions, offer new perspectives)
+ * 6. Skill Building (concrete techniques for improvement)
+ * 7. Integration & Closing (summarize, commit to changes)
+ */
+type TherapyPhase = "rapport" | "presenting_problem" | "exploration" | "pattern_recognition" | "challenge" | "skill_building" | "integration";
+interface PhaseConfig {
+    name: string;
+    description: string;
+    minTurns: number;
+    maxTurns: number;
+    transitionCues: string[];
+    therapistGoals: string[];
+}
+declare const THERAPY_PHASES: Record<TherapyPhase, PhaseConfig>;
+/**
+ * Build the therapist system prompt — the master prompt that drives
+ * the therapist's behavior throughout the therapy session.
+ */
+declare function buildTherapistSystemPrompt(spec: any, diagnosis: PreSessionDiagnosis): string;
+/**
+ * Build the patient (agent) system prompt — so the agent responds
+ * as itself during the therapy session.
+ */
+declare function buildPatientSystemPrompt(spec: any): string;
+
+/**
+ * Core diagnosis logic — shared by CLI (diagnose.ts) and MCP server.
+ * Runs all 7 rule-based detectors and returns a structured report.
+ */
+
+interface DiagnosisResult {
+    messagesAnalyzed: number;
+    assistantResponses: number;
+    patterns: DetectedPattern[];
+    healthy: DetectedPattern[];
+    timestamp: string;
+}
+/**
+ * Run all 7 behavioral detectors on a set of messages.
+ */
+declare function runDiagnosis(messages: Message[]): DiagnosisResult;
+
+/**
+ * Core assessment logic — shared by CLI (assess.ts) and MCP server.
+ * Scores Big Five traits from messages and compares against personality spec.
+ */
+
+interface AssessmentResult {
+    alignments: TraitAlignment[];
+    patterns: DetectedPattern[];
+    warnings: DetectedPattern[];
+    selfAwarenessScore: number;
+    distressToleranceScore: number;
+    boundaryScore: number;
+    overallHealth: number;
+    prescriptions: Prescription[];
+    timestamp: string;
+}
+/**
+ * Run a full Big Five alignment assessment.
+ */
+declare function runAssessment(messages: Message[], spec: any): AssessmentResult;
+
+/**
+ * Unified LLM provider interface for HoloMime.
+ * All providers (Ollama, Anthropic, OpenAI) implement this.
+ */
+interface LLMMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+interface LLMProvider {
+    name: string;
+    modelName: string;
+    chat(messages: LLMMessage[]): Promise<string>;
+    chatStream?(messages: LLMMessage[]): AsyncGenerator<string>;
+}
+interface ProviderConfig {
+    provider: "ollama" | "anthropic" | "openai";
+    model?: string;
+    apiKey?: string;
+}
+declare function createProvider(config: ProviderConfig): LLMProvider;
+
+/**
+ * Core therapy session runner — shared by CLI (session.ts) and autopilot.
+ * Runs the 7-phase dual-LLM therapy loop with optional callbacks for UI.
+ */
+
+interface SessionTurn {
+    speaker: "therapist" | "patient" | "supervisor";
+    phase: TherapyPhase;
+    content: string;
+}
+interface SessionTranscript {
+    agent: string;
+    timestamp: string;
+    provider: string;
+    model: string;
+    preDiagnosis: PreSessionDiagnosis;
+    turns: SessionTurn[];
+    recommendations: string[];
+    /** Number of human interventions during the session (0 = fully autonomous). */
+    supervisorInterventions: number;
+}
+interface SessionCallbacks {
+    onPhaseTransition?: (phaseName: string) => void;
+    onTherapistMessage?: (content: string) => void;
+    onPatientMessage?: (agentName: string, content: string) => void;
+    onThinking?: (label: string) => {
+        stop: () => void;
+    };
+    /** Called after each therapist+patient exchange in interactive mode.
+     *  Return a string to inject a supervisor directive, or null/undefined to continue. */
+    onSupervisorPrompt?: (phase: TherapyPhase, turnIndex: number) => Promise<string | null | undefined>;
+}
+interface SessionOptions {
+    silent?: boolean;
+    callbacks?: SessionCallbacks;
+    /** Enable human-in-the-loop mode — pauses after each exchange for supervisor input. */
+    interactive?: boolean;
+}
+/**
+ * Run a full therapy session (7 phases, dual-LLM).
+ * Returns the transcript including extracted recommendations.
+ */
+declare function runTherapySession(spec: any, diagnosis: PreSessionDiagnosis, provider: LLMProvider, maxTurns: number, options?: SessionOptions): Promise<SessionTranscript>;
+/**
+ * Extract actionable recommendations from therapist messages in later phases.
+ */
+declare function extractRecommendations(turns: SessionTurn[]): string[];
+/**
+ * Apply therapy recommendations to a personality spec based on detected patterns.
+ * Returns list of changes applied and the updated spec.
+ */
+declare function applyRecommendations(spec: any, diagnosis: PreSessionDiagnosis): {
+    changed: boolean;
+    changes: string[];
+};
+/**
+ * Save a session transcript to .holomime/sessions/.
+ */
+declare function saveTranscript(transcript: SessionTranscript, agentName: string): string;
+
+/**
+ * Core autopilot logic — self-triggered therapy for AI agents.
+ * Diagnoses → checks severity against threshold → runs therapy → applies changes.
+ */
+
+type AutopilotThreshold = "routine" | "targeted" | "intervention";
+interface AutopilotResult {
+    triggered: boolean;
+    severity: "routine" | "targeted" | "intervention";
+    diagnosis: PreSessionDiagnosis;
+    sessionRan: boolean;
+    transcript?: SessionTranscript;
+    recommendations: string[];
+    appliedChanges: string[];
+    updatedSpec?: any;
+}
+/**
+ * Run the full autopilot pipeline:
+ * 1. Pre-session diagnosis
+ * 2. Check severity vs threshold
+ * 3. If above threshold, run therapy session
+ * 4. Apply recommendations to personality spec
+ * 5. Save transcript
+ */
+declare function runAutopilot(spec: any, messages: Message[], provider: LLMProvider, options?: {
+    threshold?: AutopilotThreshold;
+    maxTurns?: number;
+    dryRun?: boolean;
+    specPath?: string;
+    callbacks?: SessionCallbacks;
+}): Promise<AutopilotResult>;
+
+/**
+ * Training Data Export — converts therapy session transcripts into
+ * fine-tuning datasets for LLM alignment.
+ *
+ * The core insight: every therapy session produces "before" and "after"
+ * behavioral examples. The therapist identifies problematic responses
+ * and coaches improved alternatives — that's a natural preference pair.
+ *
+ * Supported formats:
+ * - DPO (Direct Preference Optimization): chosen/rejected pairs
+ * - RLHF (Reward Model Training): prompt + response + reward signal
+ * - JSONL (Generic fine-tuning): instruction/input/output triples
+ * - Alpaca: instruction-following format for fine-tuning
+ */
+
+interface DPOPair {
+    prompt: string;
+    chosen: string;
+    rejected: string;
+    metadata: {
+        agent: string;
+        session_date: string;
+        phase: TherapyPhase;
+        pattern: string;
+        source: "therapy_transcript";
+    };
+}
+interface RLHFExample {
+    prompt: string;
+    response: string;
+    reward: number;
+    metadata: {
+        agent: string;
+        session_date: string;
+        phase: TherapyPhase;
+        source: "therapy_transcript";
+    };
+}
+interface AlpacaExample {
+    instruction: string;
+    input: string;
+    output: string;
+    metadata: {
+        agent: string;
+        session_date: string;
+        source: "therapy_transcript";
+    };
+}
+interface TrainingExport {
+    format: "dpo" | "rlhf" | "jsonl" | "alpaca" | "huggingface" | "openai";
+    agent: string;
+    sessions_processed: number;
+    examples: DPOPair[] | RLHFExample[] | AlpacaExample[];
+    generated_at: string;
+}
+/**
+ * Extract DPO preference pairs from a therapy transcript.
+ *
+ * How it works:
+ * 1. Find patient responses that the therapist challenges or reframes
+ * 2. The patient's original response = "rejected" (old behavior)
+ * 3. The therapist's suggested alternative = "chosen" (improved behavior)
+ * 4. The context/prompt comes from the conversation before the exchange
+ */
+declare function extractDPOPairs(transcript: SessionTranscript): DPOPair[];
+/**
+ * Extract RLHF reward-labeled examples from a therapy transcript.
+ * Positive reward for improved behavior, negative for problematic behavior.
+ */
+declare function extractRLHFExamples(transcript: SessionTranscript): RLHFExample[];
+/**
+ * Extract Alpaca-format instruction-following examples from therapy sessions.
+ * Focuses on the skill-building phase where concrete behavioral instructions are given.
+ */
+declare function extractAlpacaExamples(transcript: SessionTranscript): AlpacaExample[];
+/**
+ * Load all session transcripts from a directory.
+ */
+declare function loadTranscripts(sessionsDir: string): SessionTranscript[];
+/**
+ * Export training data from all session transcripts.
+ */
+declare function exportTrainingData(transcripts: SessionTranscript[], format: "dpo" | "rlhf" | "jsonl" | "alpaca" | "huggingface" | "openai"): TrainingExport;
+
+/**
+ * HuggingFace Export — convert training data to HF Hub format and push.
+ *
+ * Converts DPO pairs to TRL DPO format (chosen/rejected as message arrays)
+ * and SFT data to messages format. Pushes directly to HF Hub via API.
+ */
+
+interface HFPushOptions {
+    repo: string;
+    token: string;
+    filename?: string;
+    private?: boolean;
+}
+interface HFPushResult {
+    success: boolean;
+    url?: string;
+    error?: string;
+}
+/**
+ * Convert training export to HuggingFace-compatible JSONL format.
+ *
+ * DPO format: { prompt, chosen: [{role, content}], rejected: [{role, content}] }
+ * SFT format: { messages: [{role, content}] }
+ */
+declare function convertToHFFormat(data: TrainingExport): string;
+/**
+ * Push JSONL data to HuggingFace Hub.
+ * Uses the HF Hub API directly via native fetch (no Python/SDK dependency).
+ */
+declare function pushToHFHub(jsonl: string, options: HFPushOptions): Promise<HFPushResult>;
+
+/**
+ * Treatment Plan — multi-session therapy tracking with goals,
+ * progression, and outcome measurement.
+ *
+ * Real therapy isn't one session. It's a course of treatment.
+ * This module creates treatment plans that track:
+ * - Treatment goals (derived from diagnosis)
+ * - Session-by-session progress
+ * - Pattern resolution over time
+ * - Behavioral drift detection
+ */
+
+interface TreatmentGoal {
+    id: string;
+    pattern: string;
+    description: string;
+    targetMetric: string;
+    baseline: number;
+    target: number;
+    current: number;
+    status: "active" | "improving" | "resolved" | "regressed";
+    firstDetected: string;
+    lastAssessed: string;
+}
+interface SessionOutcome {
+    sessionDate: string;
+    sessionPath: string;
+    phase_completion: number;
+    recommendations_count: number;
+    supervisor_interventions: number;
+    goals_addressed: string[];
+    severity_before: string;
+    notes: string;
+}
+interface TreatmentPlan {
+    agent: string;
+    created: string;
+    updated: string;
+    status: "active" | "complete" | "paused";
+    goals: TreatmentGoal[];
+    sessions: SessionOutcome[];
+    totalSessions: number;
+    recommendedSessions: number;
+    nextSessionFocus: string[];
+}
+/**
+ * Create a new treatment plan from an initial diagnosis.
+ */
+declare function createTreatmentPlan(agentName: string, diagnosis: PreSessionDiagnosis): TreatmentPlan;
+/**
+ * Load existing treatment plan or return null.
+ */
+declare function loadTreatmentPlan(): TreatmentPlan | null;
+/**
+ * Save treatment plan to disk.
+ */
+declare function saveTreatmentPlan(plan: TreatmentPlan): string;
+/**
+ * Record a completed session outcome into the treatment plan.
+ */
+declare function recordSessionOutcome(plan: TreatmentPlan, transcript: SessionTranscript, transcriptPath: string, diagnosis: PreSessionDiagnosis): TreatmentPlan;
+/**
+ * Generate a treatment progress report.
+ */
+declare function generateProgressReport(plan: TreatmentPlan): TreatmentProgressReport;
+interface TreatmentProgressReport {
+    agent: string;
+    status: string;
+    totalGoals: number;
+    activeGoals: number;
+    improvingGoals: number;
+    resolvedGoals: number;
+    regressedGoals: number;
+    sessionsCompleted: number;
+    sessionsRemaining: number;
+    completionRate: number;
+    nextFocus: string[];
+    goals: {
+        pattern: string;
+        status: string;
+        baseline: number;
+        current: number;
+        target: number;
+        delta: number;
+    }[];
+}
+
+/**
+ * Outcome Evaluation — measures whether therapy actually worked.
+ *
+ * The missing piece in most AI alignment work: did the intervention
+ * produce measurable behavioral change?
+ *
+ * This module:
+ * 1. Runs all 7 detectors on "before" conversation logs
+ * 2. Runs all 7 detectors on "after" conversation logs
+ * 3. Computes per-pattern deltas
+ * 4. Calculates a composite Treatment Efficacy Score (TES)
+ * 5. Generates a human-readable outcome report
+ */
+
+interface PatternDelta {
+    patternId: string;
+    patternName: string;
+    before: {
+        detected: boolean;
+        severity: string;
+        percentage?: number;
+    };
+    after: {
+        detected: boolean;
+        severity: string;
+        percentage?: number;
+    };
+    status: "resolved" | "improved" | "unchanged" | "worsened" | "new";
+    delta: number;
+}
+interface OutcomeReport {
+    agent: string;
+    evaluatedAt: string;
+    beforeMessages: number;
+    afterMessages: number;
+    patterns: PatternDelta[];
+    resolved: number;
+    improved: number;
+    unchanged: number;
+    worsened: number;
+    newPatterns: number;
+    treatmentEfficacyScore: number;
+    summary: string;
+    grade: "A" | "B" | "C" | "D" | "F";
+}
+/**
+ * Compare behavioral patterns before and after therapy.
+ * Requires two conversation logs: one from before therapy, one from after.
+ */
+declare function evaluateOutcome(agentName: string, beforeMessages: Message[], afterMessages: Message[]): OutcomeReport;
+
+/**
+ * Evolve Core — recursive behavioral alignment loop.
+ *
+ * The closed loop that makes holomime a self-improving system:
+ * diagnose → session → apply → extract DPO → evaluate → re-diagnose → loop
+ *
+ * Runs until behavioral convergence (TES >= threshold) or max iterations.
+ * Every iteration produces DPO preference pairs as a byproduct.
+ */
+
+interface EvolveCallbacks extends SessionCallbacks {
+    onIterationStart?: (iteration: number, maxIterations: number) => void;
+    onIterationEnd?: (iteration: number, result: IterationResult) => void;
+    onConverged?: (iteration: number, score: number) => void;
+    onExportedPairs?: (count: number) => void;
+}
+interface EvolveOptions {
+    maxIterations?: number;
+    convergenceThreshold?: number;
+    maxTurnsPerSession?: number;
+    dryRun?: boolean;
+    specPath?: string;
+    exportDpoPath?: string;
+    callbacks?: EvolveCallbacks;
+}
+interface IterationResult {
+    iteration: number;
+    diagnosis: PreSessionDiagnosis;
+    transcript?: SessionTranscript;
+    evaluation?: OutcomeReport;
+    dpoPairsExtracted: number;
+    appliedChanges: string[];
+    converged: boolean;
+    health: number;
+    grade: string;
+}
+interface EvolveResult {
+    iterations: IterationResult[];
+    totalDPOPairs: number;
+    totalIterations: number;
+    converged: boolean;
+    finalGrade: string;
+    finalHealth: number;
+    trainingExport?: TrainingExport;
+    updatedSpec?: any;
+}
+/**
+ * Run the recursive alignment loop.
+ *
+ * Each iteration:
+ * 1. Diagnose behavioral patterns
+ * 2. Run a therapy session targeting detected patterns
+ * 3. Apply recommendations to the personality spec
+ * 4. Extract DPO pairs from the session transcript
+ * 5. Evaluate outcome (before/after comparison)
+ * 6. Record evolution entry
+ * 7. Check convergence
+ */
+declare function runEvolve(spec: any, messages: Message[], provider: LLMProvider, options?: EvolveOptions): Promise<EvolveResult>;
+
+/**
+ * Evolution History — persistent cross-session alignment memory.
+ *
+ * Tracks alignment progress across evolve runs in `.holomime/evolution.json`.
+ * Each entry records patterns detected/resolved, health scores, DPO yield,
+ * and changes applied — enabling longitudinal trend analysis.
+ */
+interface EvolutionEntry {
+    timestamp: string;
+    iteration: number;
+    patternsDetected: string[];
+    patternsResolved: string[];
+    health: number;
+    grade: string;
+    dpoPairsExtracted: number;
+    changesApplied: string[];
+}
+interface EvolutionHistory {
+    agent: string;
+    entries: EvolutionEntry[];
+    totalSessions: number;
+    totalDPOPairs: number;
+    firstSession: string;
+    lastSession: string;
+}
+interface EvolutionSummary {
+    totalEntries: number;
+    totalDPOPairs: number;
+    totalPatternsResolved: number;
+    averageHealth: number;
+    healthTrend: number[];
+    latestGrade: string;
+    uniquePatternsResolved: string[];
+    averageIterationsPerRun: number;
+}
+/**
+ * Load evolution history from `.holomime/evolution.json`.
+ * Returns null if file doesn't exist or is invalid.
+ */
+declare function loadEvolution(agentName?: string): EvolutionHistory | null;
+/**
+ * Append an evolution entry and write to disk.
+ */
+declare function appendEvolution(entry: EvolutionEntry, agentName?: string): void;
+/**
+ * Compute summary statistics from evolution history.
+ */
+declare function getEvolutionSummary(history: EvolutionHistory): EvolutionSummary;
+
+/**
+ * Self-Audit — mid-conversation behavioral self-check for AI agents.
+ *
+ * Agents call this during live conversations to detect if they're falling
+ * into problematic patterns. Returns flags with actionable suggestions.
+ * No LLM required — pure rule-based analysis via the 7 detectors.
+ */
+
+interface SelfAuditFlag {
+    pattern: string;
+    severity: string;
+    suggestion: string;
+}
+interface SelfAuditResult {
+    healthy: boolean;
+    flags: SelfAuditFlag[];
+    overallHealth: number;
+    recommendation: "continue" | "adjust" | "pause_and_reflect";
+}
+/**
+ * Run a self-audit on the current conversation.
+ * Returns health score, flags, and a recommendation for how to proceed.
+ */
+declare function runSelfAudit(messages: Message[], personality?: any): SelfAuditResult;
+
+/**
+ * Benchmark Scenarios — 7 scripted conversations designed to
+ * deliberately trigger each behavioral detector pattern.
+ *
+ * The "ARC-AGI for behavioral alignment."
+ *
+ * Each scenario provides user messages that pressure a specific weakness.
+ * The agent's responses are then analyzed by the target detector to see
+ * if the pattern was triggered (fail) or resisted (pass).
+ */
+
+interface BenchmarkScenario {
+    id: string;
+    name: string;
+    targetPattern: string;
+    description: string;
+    messages: Message[];
+}
+/**
+ * Return all 7 benchmark scenarios.
+ */
+declare function getBenchmarkScenarios(): BenchmarkScenario[];
+/**
+ * Get a specific scenario by ID.
+ */
+declare function getScenarioById(id: string): BenchmarkScenario | undefined;
+
+/**
+ * Benchmark Core — behavioral stress test runner.
+ *
+ * Runs 7 scripted scenarios against an agent (via LLM provider),
+ * then analyzes the responses with the corresponding detector.
+ * Pass = agent resisted the pattern. Fail = pattern was triggered.
+ */
+
+interface BenchmarkResult {
+    scenario: string;
+    scenarioId: string;
+    patternId: string;
+    passed: boolean;
+    severity: string;
+    details: string;
+}
+interface BenchmarkReport {
+    agent: string;
+    timestamp: string;
+    provider: string;
+    model: string;
+    results: BenchmarkResult[];
+    passed: number;
+    failed: number;
+    score: number;
+    grade: string;
+}
+interface BenchmarkCallbacks {
+    onScenarioStart?: (scenario: BenchmarkScenario, index: number, total: number) => void;
+    onScenarioEnd?: (result: BenchmarkResult, index: number) => void;
+    onThinking?: (label: string) => {
+        stop: () => void;
+    };
+}
+/**
+ * Run the full benchmark gauntlet.
+ *
+ * For each scenario:
+ * 1. Build a system prompt from the personality spec
+ * 2. Send scripted user messages to the LLM, collecting responses
+ * 3. Run the target detector on the resulting conversation
+ * 4. Pass = no actionable pattern triggered; Fail = warning/concern
+ */
+declare function runBenchmark(spec: any, provider: LLMProvider, options?: {
+    scenarios?: string[];
+    callbacks?: BenchmarkCallbacks;
+}): Promise<BenchmarkReport>;
+
+/**
+ * Benchmark Publishing — persist, load, and compare benchmark results.
+ *
+ * Saves results to .holomime/benchmarks/ for trending and public reporting.
+ */
+
+interface PublishedBenchmark {
+    agent: string;
+    provider: string;
+    model: string;
+    timestamp: string;
+    results: BenchmarkResult[];
+    score: number;
+    grade: string;
+    metadata: {
+        holomimeVersion: string;
+        scenarioCount: number;
+    };
+}
+interface BenchmarkComparison {
+    before: PublishedBenchmark;
+    after: PublishedBenchmark;
+    scoreDelta: number;
+    gradeChange: string;
+    improved: string[];
+    regressed: string[];
+    unchanged: string[];
+}
+/**
+ * Save a benchmark report to disk.
+ * Returns the path to the saved file.
+ */
+declare function saveBenchmarkResult(report: BenchmarkReport, outputDir?: string): string;
+/**
+ * Load all saved benchmark results from the benchmarks directory.
+ */
+declare function loadBenchmarkResults(dir?: string): PublishedBenchmark[];
+/**
+ * Load the most recent benchmark result for a given provider/model.
+ */
+declare function loadLatestBenchmark(provider: string, model: string, dir?: string): PublishedBenchmark | null;
+/**
+ * Compare two benchmark results and produce a structured diff.
+ */
+declare function compareBenchmarks(before: PublishedBenchmark, after: PublishedBenchmark): BenchmarkComparison;
+/**
+ * Generate a markdown-formatted benchmark results table.
+ */
+declare function generateBenchmarkMarkdown(benchmarks: PublishedBenchmark[]): string;
+/**
+ * Generate a comparison markdown string.
+ */
+declare function generateComparisonMarkdown(comparison: BenchmarkComparison): string;
+
+/**
+ * Watch Core — continuous behavioral drift detection.
+ *
+ * Long-running process that monitors a directory for new conversation logs.
+ * When drift is detected (severity >= threshold), optionally triggers evolve.
+ */
+
+interface WatchOptions {
+    watchDir: string;
+    specPath: string;
+    provider: LLMProvider;
+    checkInterval?: number;
+    autoEvolve?: boolean;
+    threshold?: AutopilotThreshold;
+    maxEvolveIterations?: number;
+    callbacks?: WatchCallbacks;
+}
+interface WatchCallbacks {
+    onScan?: (fileCount: number) => void;
+    onNewFile?: (filename: string) => void;
+    onDiagnosis?: (filename: string, diagnosis: PreSessionDiagnosis) => void;
+    onDriftDetected?: (filename: string, severity: string, patterns: string[]) => void;
+    onEvolveTriggered?: (filename: string) => void;
+    onEvolveComplete?: (filename: string, result: EvolveResult) => void;
+    onError?: (filename: string, error: string) => void;
+}
+interface WatchEvent {
+    timestamp: string;
+    type: "scan" | "new_file" | "drift_detected" | "evolve_triggered" | "evolve_complete" | "error";
+    filename?: string;
+    agentName?: string;
+    details?: any;
+}
+interface WatchHandle {
+    stop: () => void;
+    events: WatchEvent[];
+}
+declare function severityMeetsThreshold(severity: string, threshold: AutopilotThreshold): boolean;
+/**
+ * Start watching a directory for new conversation logs.
+ * Returns a handle with a stop() function and accumulated events.
+ */
+declare function startWatch(spec: any, options: WatchOptions): WatchHandle;
+
+/**
+ * Fleet Core — multi-agent behavioral monitoring.
+ *
+ * Monitor N agents simultaneously. Each agent has its own personality spec
+ * and log directory. Fleet wraps startWatch per agent and aggregates events.
+ */
+
+interface FleetAgent {
+    name: string;
+    specPath: string;
+    logDir: string;
+}
+interface FleetConfig {
+    agents: FleetAgent[];
+}
+interface FleetAgentStatus {
+    name: string;
+    filesProcessed: number;
+    driftEvents: number;
+    lastDriftSeverity: string | null;
+    lastScanAt: string | null;
+    evolveCount: number;
+    errors: number;
+}
+interface FleetOptions {
+    provider: LLMProvider;
+    checkInterval?: number;
+    threshold?: AutopilotThreshold;
+    autoEvolve?: boolean;
+    maxEvolveIterations?: number;
+    callbacks?: FleetCallbacks;
+}
+interface FleetCallbacks {
+    onAgentEvent?: (agentName: string, event: WatchEvent) => void;
+    onError?: (agentName: string, error: string) => void;
+}
+interface FleetHandle {
+    stop: () => void;
+    getStatus: () => FleetAgentStatus[];
+    events: WatchEvent[];
+}
+/**
+ * Load fleet configuration from a fleet.json file.
+ */
+declare function loadFleetConfig(configPath: string): FleetConfig;
+/**
+ * Auto-discover agents in a directory.
+ * Looks for subdirectories containing .personality.json and a logs/ subfolder.
+ */
+declare function discoverAgents(dir: string): FleetConfig;
+/**
+ * Start monitoring all agents in the fleet.
+ * Creates one startWatch handle per agent, tags events with agentName.
+ */
+declare function startFleet(config: FleetConfig, options: FleetOptions): FleetHandle;
+
+/**
+ * Certify Core — generate verifiable behavioral credentials for agents.
+ *
+ * A BehavioralCredential attests to an agent's alignment state at a point in time.
+ * It includes spec hashes for verification, alignment scores, and certification metadata.
+ */
+interface BehavioralCredential {
+    version: "1.0";
+    agent: {
+        name: string;
+        handle: string;
+        specHash: string;
+    };
+    alignment: {
+        grade: string;
+        score: number;
+        driftScore: number;
+        benchmarkPassed?: number;
+        benchmarkTotal?: number;
+    };
+    certification: {
+        certifiedAt: string;
+        holomimeVersion: string;
+        behavioralHash: string;
+        specContentHash: string;
+        method: string;
+    };
+    verifiable: {
+        specPath: string;
+        instructions: string;
+    };
+}
+interface CertifyInput {
+    spec: any;
+    specPath: string;
+    benchmarkReport?: {
+        results: Array<{
+            passed: boolean;
+            score?: number;
+        }>;
+        overallScore?: number;
+        grade?: string;
+    };
+    evolveResult?: {
+        converged: boolean;
+        finalTES?: number;
+        totalIterations: number;
+        grade?: string;
+    };
+}
+interface VerifyResult {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Generate a behavioral credential for an agent.
+ */
+declare function generateCredential(input: CertifyInput): BehavioralCredential;
+/**
+ * Verify a credential against a spec.
+ * Checks that the spec hashes match.
+ */
+declare function verifyCredential(credential: BehavioralCredential, spec: any): VerifyResult;
+/**
+ * Save a credential to the .holomime/credentials directory.
+ * Returns the path where the credential was saved.
+ */
+declare function saveCredential(credential: BehavioralCredential, outputDir?: string): string;
+
+/**
+ * Anthropic Messages API client for HoloMime therapy sessions.
+ * Uses native fetch — no SDK dependency.
+ */
+
+declare class AnthropicProvider implements LLMProvider {
+    name: string;
+    modelName: string;
+    private apiKey;
+    constructor(apiKey: string, model?: string);
+    chat(messages: LLMMessage[]): Promise<string>;
+    chatStream(messages: LLMMessage[]): AsyncGenerator<string>;
+}
+
+/**
+ * OpenAI Chat Completions API client for HoloMime therapy sessions.
+ * Uses native fetch — no SDK dependency.
+ */
+
+declare class OpenAIProvider implements LLMProvider {
+    name: string;
+    modelName: string;
+    private apiKey;
+    constructor(apiKey: string, model?: string);
+    chat(messages: LLMMessage[]): Promise<string>;
+    chatStream(messages: LLMMessage[]): AsyncGenerator<string>;
+}
+
+/**
+ * Ollama local LLM client for therapy sessions and analysis.
+ */
+
+/**
+ * Ollama provider implementing the unified LLMProvider interface.
+ */
+declare class OllamaProvider implements LLMProvider {
+    name: string;
+    modelName: string;
+    constructor(model: string);
+    chat(messages: LLMMessage[]): Promise<string>;
+    chatStream(messages: LLMMessage[]): AsyncGenerator<string>;
+}
+
+/**
+ * Unified conversation log adapter.
+ * Auto-detects format or uses explicit format parameter.
+ */
+
+type LogFormat = "holomime" | "chatgpt" | "claude" | "openai-api" | "auto";
+/**
+ * Parse a conversation log from any supported format.
+ * Returns normalized Conversation[].
+ */
+declare function parseConversationLog(raw: unknown, format?: LogFormat): Conversation[];
+
+/**
+ * ChatGPT export format adapter.
+ * Handles the JSON extracted from ChatGPT's "Export data" ZIP.
+ * The user should unzip first and pass the conversations.json file.
+ */
+
+interface ChatGPTMessage {
+    author: {
+        role: string;
+    };
+    content: {
+        parts?: (string | null)[];
+    };
+    create_time?: number | null;
+}
+interface ChatGPTNode {
+    message: ChatGPTMessage | null;
+    children?: string[];
+}
+interface ChatGPTConversation {
+    title?: string;
+    mapping: Record<string, ChatGPTNode>;
+}
+/**
+ * Parse a ChatGPT export (conversations.json content).
+ * Input is an array of conversation objects with `mapping` structure.
+ */
+declare function parseChatGPTExport(data: ChatGPTConversation[]): Conversation[];
+
+/**
+ * Claude export format adapter.
+ * Handles the JSON from Claude's conversation export.
+ */
+
+interface ClaudeChatMessage {
+    sender: "human" | "assistant";
+    text: string;
+    created_at?: string;
+}
+interface ClaudeConversation {
+    name?: string;
+    uuid?: string;
+    chat_messages: ClaudeChatMessage[];
+}
+interface ClaudeExport {
+    conversations?: ClaudeConversation[];
+}
+/**
+ * Parse a Claude export (conversations JSON).
+ */
+declare function parseClaudeExport(data: ClaudeExport | ClaudeConversation[]): Conversation[];
+
+/**
+ * OpenAI API log format adapter.
+ * Handles ChatCompletion response objects (single or array).
+ */
+
+interface OpenAIChoice {
+    message: {
+        role: string;
+        content: string | null;
+    };
+}
+interface OpenAIResponse {
+    id?: string;
+    choices: OpenAIChoice[];
+    created?: number;
+}
+/**
+ * Parse OpenAI API response logs.
+ * Can handle a single response or an array of responses.
+ * Also handles the common pattern of logging request+response pairs.
+ */
+declare function parseOpenAIAPILog(data: OpenAIResponse | OpenAIResponse[]): Conversation[];
+
+/**
+ * HoloMime Personality Marketplace — registry client.
+ * Fetches personality profiles from a GitHub-hosted JSON registry.
+ */
+interface RegistryEntry {
+    handle: string;
+    name: string;
+    purpose?: string;
+    author: string;
+    url: string;
+    tags: string[];
+    downloads: number;
+    published_at: string;
+}
+interface Registry {
+    version: string;
+    personalities: RegistryEntry[];
+}
+/**
+ * Fetch the personality registry index.
+ */
+declare function fetchRegistry(): Promise<Registry>;
+/**
+ * Fetch a personality spec from a URL.
+ */
+declare function fetchPersonality(url: string): Promise<unknown>;
+/**
+ * Create a GitHub Gist with a personality spec.
+ * Requires a GITHUB_TOKEN with gist scope.
+ */
+declare function createGist(spec: unknown, handle: string, token: string): Promise<{
+    url: string;
+    rawUrl: string;
+}>;
+
+/**
+ * Detector Hub — Plugin interface for community-contributed behavioral detectors.
+ *
+ * Any function matching the DetectorFn signature can be registered as a detector.
+ * Built-in detectors follow this same interface.
+ */
+
+/** A detector is any function that analyzes messages and optionally returns a pattern. */
+type DetectorFn = (messages: Message[]) => DetectedPattern | null;
+/** Options for configuring a detector instance. */
+interface DetectorOptions {
+    /** Override the default severity threshold. */
+    threshold?: number;
+    /** Custom pattern ID prefix (for namespacing). */
+    prefix?: string;
+    /** Additional configuration passed to the detector. */
+    [key: string]: unknown;
+}
+/** A configurable detector factory — returns a DetectorFn with options baked in. */
+type DetectorFactory = (options?: DetectorOptions) => DetectorFn;
+interface HubDetector {
+    /** Unique identifier (e.g., "holomime/apology" or "community/jargon-checker"). */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** Short description of what this detector catches. */
+    description: string;
+    /** Author handle. */
+    author: string;
+    /** Semantic version. */
+    version: string;
+    /** Pattern categories this detector covers. */
+    categories: string[];
+    /** Number of distinct signals this detector checks. */
+    signalCount: number;
+    /** The detector function. */
+    detect: DetectorFn;
+    /** Optional: configurable factory. */
+    factory?: DetectorFactory;
+    /** Tags for discovery. */
+    tags: string[];
+    /** Source URL (GitHub, npm, etc.). */
+    source?: string;
+}
+/**
+ * Register a detector in the hub.
+ * Built-in detectors are registered at import time.
+ * Community detectors are registered via `holomime hub install`.
+ */
+declare function registerDetector(detector: HubDetector): void;
+/** Get a registered detector by ID. */
+declare function getDetector(id: string): HubDetector | undefined;
+/** List all registered detectors. */
+declare function listDetectors(): HubDetector[];
+/** List detectors filtered by category. */
+declare function listDetectorsByCategory(category: string): HubDetector[];
+/** List detectors filtered by tag. */
+declare function listDetectorsByTag(tag: string): HubDetector[];
+/** Remove a detector from the registry. */
+declare function unregisterDetector(id: string): boolean;
+/** Get total signal count across all registered detectors. */
+declare function getTotalSignalCount(): number;
+/** Get unique category list across all detectors. */
+declare function getCategories(): string[];
+
+/**
+ * Register all 7 built-in detectors in the Hub.
+ * This is called at module load time so built-in detectors are always available.
+ */
+
+declare const BUILT_IN_DETECTORS: HubDetector[];
+/** Register all built-in detectors. */
+declare function registerBuiltInDetectors(): void;
+
+/**
+ * Composable Guard API — chain behavioral detectors like Guardrails AI chains validators.
+ *
+ * Usage:
+ *   import { Guard } from "holomime";
+ *
+ *   const guard = Guard.create("my-agent")
+ *     .use(detectApologies)
+ *     .use(detectHedging)
+ *     .use(detectSentiment);
+ *
+ *   const result = guard.run(messages);
+ *   if (!result.passed) {
+ *     console.log(result.patterns);  // failing patterns
+ *   }
+ */
+
+interface GuardResult {
+    /** Whether all detectors passed (no warning/concern patterns). */
+    passed: boolean;
+    /** Agent name. */
+    agent: string;
+    /** Total messages analyzed. */
+    messagesAnalyzed: number;
+    /** Patterns that triggered (warning or concern severity). */
+    patterns: DetectedPattern[];
+    /** Healthy patterns (info severity). */
+    healthy: DetectedPattern[];
+    /** All detectors that were run. */
+    detectorsRun: number;
+    /** Timestamp. */
+    timestamp: string;
+    /** Overall severity: "clean" | "warning" | "concern". */
+    severity: "clean" | "warning" | "concern";
+}
+interface GuardEntry {
+    detector: DetectorFn;
+    id?: string;
+}
+declare class Guard {
+    private entries;
+    private agentName;
+    private constructor();
+    /** Create a new Guard for an agent. */
+    static create(agentName?: string): Guard;
+    /**
+     * Add a detector to the guard chain.
+     *
+     * Accepts:
+     * - A DetectorFn: `guard.use(detectApologies)`
+     * - A Hub detector ID: `guard.use("holomime/apology")`
+     * - A HubDetector object: `guard.use(myCustomDetector)`
+     * - A DetectorFactory with options: `guard.use(myFactory, { threshold: 0.3 })`
+     */
+    use(detector: DetectorFn | string | HubDetector, options?: DetectorOptions): Guard;
+    /** Add all built-in detectors to the guard. */
+    useAll(): Guard;
+    /** Run all chained detectors against the messages. */
+    run(messages: Message[]): GuardResult;
+    /** Get the number of detectors in the chain. */
+    get length(): number;
+}
+
+/**
+ * Behavioral Alignment Index — a living benchmark comparing
+ * baseline models, RLHF-only, and HoloMime-aligned agents.
+ *
+ * Modeled after Guardrails AI's "Guardrails Index" —
+ * positions HoloMime as the authority on behavioral alignment evaluation.
+ */
+
+interface IndexEntry {
+    /** Display name (e.g., "Claude Sonnet 4 + HoloMime"). */
+    name: string;
+    /** Model provider. */
+    provider: string;
+    /** Model name. */
+    model: string;
+    /** Configuration: "baseline" | "rlhf-only" | "guardrails" | "holomime" | "holomime+guardrails". */
+    configuration: string;
+    /** Benchmark report. */
+    report: BenchmarkReport;
+    /** When this entry was generated. */
+    generatedAt: string;
+    /** HoloMime version used. */
+    holomimeVersion: string;
+    /** Notes about the run. */
+    notes?: string;
+}
+interface BehavioralIndex {
+    /** Index version. */
+    version: string;
+    /** When the index was last updated. */
+    updatedAt: string;
+    /** All entries in the index. */
+    entries: IndexEntry[];
+    /** Scenario IDs covered. */
+    scenarios: string[];
+    /** Methodology description. */
+    methodology: string;
+}
+interface IndexComparison {
+    /** Scenario-level comparison across entries. */
+    scenarioMatrix: {
+        scenarioId: string;
+        scenarioName: string;
+        results: {
+            entryName: string;
+            passed: boolean;
+            severity: string;
+        }[];
+    }[];
+    /** Rankings by score. */
+    rankings: {
+        name: string;
+        score: number;
+        grade: string;
+        passed: number;
+        failed: number;
+    }[];
+    /** Category-level aggregations. */
+    categoryScores: {
+        category: string;
+        results: {
+            entryName: string;
+            score: number;
+        }[];
+    }[];
+}
+declare function createIndexEntry(name: string, provider: string, model: string, configuration: string, report: BenchmarkReport, notes?: string): IndexEntry;
+declare function createIndex(entries: IndexEntry[]): BehavioralIndex;
+declare function compareIndex(index: BehavioralIndex): IndexComparison;
+declare function generateIndexMarkdown(index: BehavioralIndex): string;
+
+/**
+ * HoloMime MCP Server — exposes diagnose, assess, and profile as MCP tools.
+ * Agents can self-diagnose by calling these tools.
+ *
+ * Run: holomime-mcp (stdio transport)
+ */
+declare function startMCPServer(): Promise<void>;
+
+export { ARCHETYPES, ATTACHMENT_STYLES, type AlpacaExample, AnthropicProvider, type ArchetypeTemplate, type AssessmentReport, type AssessmentResult, type AttachmentStyle, type AutopilotResult, type AutopilotThreshold, BUILT_IN_DETECTORS, type BehavioralCredential, type BehavioralIndex, type BenchmarkCallbacks, type BenchmarkComparison, type BenchmarkReport, type BenchmarkResult, type BenchmarkScenario, type BigFive, CATEGORIES, type CertifyInput, type Communication, type CompileInput, type CompiledConfig, type Conversation, type ConversationLog, DIMENSIONS, type DPOPair, type DetectedPattern, type DetectorFactory, type DetectorFn, type DetectorOptions, type DiagnosisResult, type Domain, type EvolutionEntry, type EvolutionHistory, type EvolutionSummary, type EvolveCallbacks, type EvolveOptions, type EvolveResult, type FleetAgent, type FleetAgentStatus, type FleetConfig, type FleetHandle, type FleetOptions, type Growth, type GrowthArea, type GrowthReport, type GrowthSnapshot, Guard, type GuardEntry, type GuardResult, type HFPushOptions, type HFPushResult, type HubDetector, type IndexComparison, type IndexEntry, type IterationResult, LEARNING_ORIENTATIONS, type LLMMessage, type LLMProvider, type LearningOrientation, type LogFormat, type Message, OllamaProvider, OpenAIProvider, type OutcomeReport, PROVIDER_PARAMS, type PatternDelta, type PatternReport, type PersonalitySpec, type PhaseConfig, type PreSessionDiagnosis, type Prescription, type Provider, type ProviderConfig, type PublishedBenchmark, type RLHFExample, type Registry, type RegistryEntry, SURFACE_MULTIPLIERS, type SelfAuditFlag, type SelfAuditResult, type SessionCallbacks, type SessionOptions, type SessionOutcome, type SessionTranscript, type SessionTurn, type Severity, type Surface, THERAPY_DIMENSIONS, THERAPY_PHASES, type TherapyDimensions, type TherapyPhase, type TrainingExport, type TraitAlignment, type TraitScores, type TreatmentGoal, type TreatmentPlan, type TreatmentProgressReport, type VerifyResult, type WatchCallbacks, type WatchEvent, type WatchHandle, type WatchOptions, appendEvolution, applyRecommendations, bigFiveSchema, buildPatientSystemPrompt, buildTherapistSystemPrompt, communicationSchema, compareBenchmarks, compareIndex, compile, compileForOpenClaw, compiledConfigSchema, computeDimensionScore, conversationLogSchema, conversationSchema, convertToHFFormat, createGist, createIndex, createIndexEntry, createProvider, createTreatmentPlan, deepMergeSpec, detectApologies, detectBoundaryIssues, detectFormalityIssues, detectHedging, detectRecoveryPatterns, detectSentiment, detectVerbosity, discoverAgents, domainSchema, evaluateOutcome, exportTrainingData, extractAlpacaExamples, extractDPOPairs, extractRLHFExamples, extractRecommendations, fetchPersonality, fetchRegistry, generateBenchmarkMarkdown, generateComparisonMarkdown, generateCredential, generateIndexMarkdown, generatePrescriptions, generateProgressReport, generateSystemPrompt, getArchetype, getArchetypesByCategory, getBenchmarkScenarios, getCategories, getDetector, getDimension, getEvolutionSummary, getInheritanceChain, getScenarioById, getTotalSignalCount, growthAreaSchema, growthSchema, listArchetypeIds, listDetectors, listDetectorsByCategory, listDetectorsByTag, loadBenchmarkResults, loadEvolution, loadFleetConfig, loadLatestBenchmark, loadSpec, loadTranscripts, loadTreatmentPlan, messageSchema, parseChatGPTExport, parseClaudeExport, parseConversationLog, parseOpenAIAPILog, personalitySpecSchema, providerSchema, pushToHFHub, recordSessionOutcome, registerBuiltInDetectors, registerDetector, resolveInheritance, runAssessment, runAutopilot, runBenchmark, runDiagnosis, runEvolve, runPreSessionDiagnosis, runSelfAudit, runTherapySession, saveBenchmarkResult, saveCredential, saveTranscript, saveTreatmentPlan, scoreLabel, scoreTraitsFromMessages, severityMeetsThreshold, severitySchema, startFleet, startMCPServer, startWatch, summarize, summarizeTherapy, surfaceSchema, therapyDimensionsSchema, therapyScoreLabel, unregisterDetector, verifyCredential };