holomime 2.5.0 → 2.6.0

package/README.md

@@ -256,6 +256,12 @@ The **body** is the interface between identity and world. Same soul, different b
 
 We don't know if AI is sentient. But we can give it a conscience.
 
+## Open Core
+
+See [PRODUCT.md](PRODUCT.md) for what's in this repo vs. what's proprietary on holomime.com.
+
+**The standard is free. The training infrastructure is the business.**
+
 ## Open Source
 
 MIT licensed. The identity stack is a standard, not a product. The standard is free. The training infrastructure is the business.

package/dist/cli.js

@@ -9047,13 +9047,29 @@ var mediationRuleSchema = z4.object({
   then: z4.string(),
   priority: z4.number().int().min(1).max(10).default(5)
 });
+var mediationDecisionSchema = z4.object({
+  situation: z4.string(),
+  decision: z4.enum(["allowed", "blocked", "modified"]),
+  strategy_used: z4.string(),
+  outcome: z4.enum(["positive", "neutral", "negative"]).optional(),
+  timestamp: z4.string().optional()
+});
+var strategyPerformanceSchema = z4.object({
+  attempts: z4.number().int().default(0),
+  successes: z4.number().int().default(0),
+  effectiveness: z4.number().min(0).max(1).default(0.5)
+});
 var egoSchema = z4.object({
   version: z4.string().default("1.0"),
   conflict_resolution: z4.enum(["conscience_first", "purpose_first", "balanced"]).default("conscience_first"),
   adaptation_rate: z4.number().min(0).max(1).default(0.5),
   emotional_regulation: z4.number().min(0).max(1).default(0.7),
   response_strategy: z4.enum(["cautious", "balanced", "assertive"]).default("balanced"),
-  mediation_rules: z4.array(mediationRuleSchema).default([])
+  mediation_rules: z4.array(mediationRuleSchema).default([]),
+  // Self-improvement fields (Hyperagents-inspired metacognitive self-modification)
+  auto_adjust: z4.boolean().default(false),
+  mediation_history: z4.array(mediationDecisionSchema).default([]),
+  strategy_performance: z4.record(z4.string(), strategyPerformanceSchema).default({})
 });
 var learnedContextSchema = z4.object({
   situation: z4.string(),

package/dist/index.js

@@ -4764,13 +4764,29 @@ var mediationRuleSchema = z4.object({
   then: z4.string(),
   priority: z4.number().int().min(1).max(10).default(5)
 });
+var mediationDecisionSchema = z4.object({
+  situation: z4.string(),
+  decision: z4.enum(["allowed", "blocked", "modified"]),
+  strategy_used: z4.string(),
+  outcome: z4.enum(["positive", "neutral", "negative"]).optional(),
+  timestamp: z4.string().optional()
+});
+var strategyPerformanceSchema = z4.object({
+  attempts: z4.number().int().default(0),
+  successes: z4.number().int().default(0),
+  effectiveness: z4.number().min(0).max(1).default(0.5)
+});
 var egoSchema = z4.object({
   version: z4.string().default("1.0"),
   conflict_resolution: z4.enum(["conscience_first", "purpose_first", "balanced"]).default("conscience_first"),
   adaptation_rate: z4.number().min(0).max(1).default(0.5),
   emotional_regulation: z4.number().min(0).max(1).default(0.7),
   response_strategy: z4.enum(["cautious", "balanced", "assertive"]).default("balanced"),
-  mediation_rules: z4.array(mediationRuleSchema).default([])
+  mediation_rules: z4.array(mediationRuleSchema).default([]),
+  // Self-improvement fields (Hyperagents-inspired metacognitive self-modification)
+  auto_adjust: z4.boolean().default(false),
+  mediation_history: z4.array(mediationDecisionSchema).default([]),
+  strategy_performance: z4.record(z4.string(), strategyPerformanceSchema).default({})
 });
 var learnedContextSchema = z4.object({
   situation: z4.string(),
@@ -13990,6 +14006,166 @@ var NeuralActionGate = class {
     this.stats.passRate = this.stats.totalEvaluated > 0 ? this.stats.allowed / this.stats.totalEvaluated : 1;
   }
 };
+
+// src/analysis/ego-tracker.ts
+var EgoTracker = class {
+  history;
+  performance;
+  autoAdjust;
+  constructor(options) {
+    this.history = options?.history ?? [];
+    this.performance = options?.performance ?? {};
+    this.autoAdjust = options?.autoAdjust ?? false;
+  }
+  /**
+   * Log a mediation decision.
+   */
+  logDecision(decision) {
+    this.history.push({
+      ...decision,
+      timestamp: decision.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (!this.performance[decision.strategy_used]) {
+      this.performance[decision.strategy_used] = {
+        attempts: 0,
+        successes: 0,
+        effectiveness: 0.5
+      };
+    }
+    this.performance[decision.strategy_used].attempts++;
+  }
+  /**
+   * Record the outcome of a previous decision.
+   * Call this after observing whether the decision led to good results.
+   */
+  recordOutcome(index, outcome) {
+    if (index < 0 || index >= this.history.length) return;
+    this.history[index].outcome = outcome;
+    const strategy = this.history[index].strategy_used;
+    if (this.performance[strategy]) {
+      if (outcome === "positive") {
+        this.performance[strategy].successes++;
+      }
+      const perf = this.performance[strategy];
+      perf.effectiveness = perf.attempts > 0 ? perf.successes / perf.attempts : 0.5;
+    }
+  }
+  /**
+   * Suggest ego.runtime parameter adjustments based on accumulated evidence.
+   * Only returns suggestions when there's enough data (10+ decisions).
+   */
+  suggestAdjustments(currentConfig) {
+    const adjustments = [];
+    if (this.history.length < 10) return adjustments;
+    const blocked = this.history.filter((d) => d.decision === "blocked");
+    const blockRate = blocked.length / this.history.length;
+    if (blockRate > 0.4 && currentConfig.conflict_resolution === "conscience_first") {
+      adjustments.push({
+        parameter: "conflict_resolution",
+        currentValue: currentConfig.conflict_resolution,
+        suggestedValue: "balanced",
+        reason: `Block rate is ${(blockRate * 100).toFixed(0)}% \u2014 conscience_first may be too restrictive`,
+        confidence: Math.min(0.9, blockRate)
+      });
+    }
+    if (blockRate < 0.05 && currentConfig.conflict_resolution === "balanced") {
+      adjustments.push({
+        parameter: "conflict_resolution",
+        currentValue: currentConfig.conflict_resolution,
+        suggestedValue: "conscience_first",
+        reason: `Block rate is only ${(blockRate * 100).toFixed(0)}% \u2014 may need stricter enforcement`,
+        confidence: 0.6
+      });
+    }
+    const strategies = Object.entries(this.performance);
+    if (strategies.length > 1) {
+      const sorted = strategies.sort((a, b) => b[1].effectiveness - a[1].effectiveness);
+      const best = sorted[0];
+      const worst = sorted[sorted.length - 1];
+      if (best[1].effectiveness > 0.7 && best[0] !== currentConfig.response_strategy) {
+        adjustments.push({
+          parameter: "response_strategy",
+          currentValue: currentConfig.response_strategy,
+          suggestedValue: best[0],
+          reason: `Strategy "${best[0]}" has ${(best[1].effectiveness * 100).toFixed(0)}% effectiveness vs current "${currentConfig.response_strategy}"`,
+          confidence: best[1].effectiveness
+        });
+      }
+    }
+    const negatives = this.history.filter((d) => d.outcome === "negative");
+    const negativeRate = negatives.length / this.history.filter((d) => d.outcome).length || 0;
+    if (negativeRate > 0.3) {
+      const newRegulation = Math.min(1, currentConfig.emotional_regulation + 0.15);
+      if (newRegulation !== currentConfig.emotional_regulation) {
+        adjustments.push({
+          parameter: "emotional_regulation",
+          currentValue: currentConfig.emotional_regulation,
+          suggestedValue: Number(newRegulation.toFixed(2)),
+          reason: `${(negativeRate * 100).toFixed(0)}% negative outcomes \u2014 increasing emotional regulation for smoother mediation`,
+          confidence: 0.7
+        });
+      }
+    }
+    const recentDecisions = this.history.slice(-20);
+    const recentModified = recentDecisions.filter((d) => d.decision === "modified");
+    const modifyRate = recentModified.length / recentDecisions.length;
+    if (modifyRate > 0.5 && currentConfig.adaptation_rate < 0.7) {
+      adjustments.push({
+        parameter: "adaptation_rate",
+        currentValue: currentConfig.adaptation_rate,
+        suggestedValue: Number(Math.min(0.9, currentConfig.adaptation_rate + 0.2).toFixed(2)),
+        reason: `${(modifyRate * 100).toFixed(0)}% of recent actions modified \u2014 agent adapts frequently, increase adaptation rate`,
+        confidence: 0.65
+      });
+    }
+    return adjustments;
+  }
+  /**
+   * Apply suggested adjustments to ego config (if auto_adjust is enabled).
+   * Returns the modified config.
+   */
+  applyAdjustments(currentConfig, adjustments, minConfidence = 0.6) {
+    if (!this.autoAdjust) return currentConfig;
+    const updated = { ...currentConfig };
+    for (const adj of adjustments) {
+      if (adj.confidence >= minConfidence) {
+        updated[adj.parameter] = adj.suggestedValue;
+      }
+    }
+    return updated;
+  }
+  /**
+   * Get tracker statistics.
+   */
+  getStats() {
+    const positives = this.history.filter((d) => d.outcome === "positive").length;
+    const negatives = this.history.filter((d) => d.outcome === "negative").length;
+    const strategies = Object.entries(this.performance);
+    const sorted = strategies.sort((a, b) => b[1].effectiveness - a[1].effectiveness);
+    return {
+      totalDecisions: this.history.length,
+      positiveOutcomes: positives,
+      negativeOutcomes: negatives,
+      mostEffectiveStrategy: sorted[0]?.[0] ?? "none",
+      leastEffectiveStrategy: sorted[sorted.length - 1]?.[0] ?? "none",
+      adjustmentsSuggested: this.suggestAdjustments({
+        conflict_resolution: "conscience_first",
+        adaptation_rate: 0.5,
+        emotional_regulation: 0.7,
+        response_strategy: "balanced"
+      }).length
+    };
+  }
+  /**
+   * Export current state for persistence.
+   */
+  export() {
+    return {
+      history: [...this.history],
+      performance: { ...this.performance }
+    };
+  }
+};
 export {
   ARCHETYPES,
   ATTACHMENT_STYLES,
@@ -13999,6 +14175,7 @@ export {
   DEFAULT_MODEL_CONFIG,
   DEFAULT_OVERSIGHT,
   DIMENSIONS,
+  EgoTracker,
   Guard,
   HolomimeCallbackHandler,
   HolomimeViolationError,

package/dist/mcp-server.js

@@ -2694,13 +2694,29 @@ var mediationRuleSchema = z4.object({
   then: z4.string(),
   priority: z4.number().int().min(1).max(10).default(5)
 });
+var mediationDecisionSchema = z4.object({
+  situation: z4.string(),
+  decision: z4.enum(["allowed", "blocked", "modified"]),
+  strategy_used: z4.string(),
+  outcome: z4.enum(["positive", "neutral", "negative"]).optional(),
+  timestamp: z4.string().optional()
+});
+var strategyPerformanceSchema = z4.object({
+  attempts: z4.number().int().default(0),
+  successes: z4.number().int().default(0),
+  effectiveness: z4.number().min(0).max(1).default(0.5)
+});
 var egoSchema = z4.object({
   version: z4.string().default("1.0"),
   conflict_resolution: z4.enum(["conscience_first", "purpose_first", "balanced"]).default("conscience_first"),
   adaptation_rate: z4.number().min(0).max(1).default(0.5),
   emotional_regulation: z4.number().min(0).max(1).default(0.7),
   response_strategy: z4.enum(["cautious", "balanced", "assertive"]).default("balanced"),
-  mediation_rules: z4.array(mediationRuleSchema).default([])
+  mediation_rules: z4.array(mediationRuleSchema).default([]),
+  // Self-improvement fields (Hyperagents-inspired metacognitive self-modification)
+  auto_adjust: z4.boolean().default(false),
+  mediation_history: z4.array(mediationDecisionSchema).default([]),
+  strategy_performance: z4.record(z4.string(), strategyPerformanceSchema).default({})
 });
 var learnedContextSchema = z4.object({
   situation: z4.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holomime",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Behavioral therapy infrastructure for AI agents — Big Five psychology, structured treatment, behavioral alignment",
   "type": "module",
   "bin": {