holomime 2.4.0 → 2.6.0

package/README.md

@@ -85,7 +85,7 @@ holomime diagnose --log agent.jsonl
 holomime benchmark --personality .personality.json
 
 # Push identity to a robot or avatar
-holomime embody --body registry/bodies/figure-02.body.api
+holomime embody --body registry/bodies/figure-03.body.api
 ```
 
 ## Robotics Integrations
@@ -100,6 +100,7 @@ holomime embody --body registry/bodies/figure-02.body.api
 | Unity | Real-time personality push via HTTP/SSE | `--adapter unity` |
 | gRPC | Custom robotics stacks | `--adapter grpc` |
 | MQTT | IoT/edge robots | `--adapter mqtt` |
+| Neural Action Gate | Conscience gate for learned controllers (VLA, RL, IL) | `neural-action-gate.ts` |
 
 ## ISO Compliance
 
@@ -130,8 +131,9 @@ Pre-built body profiles for commercial robots and virtual avatars. Each defines
 
 | Template | OEM | DOF | Morphology | File |
 |----------|-----|----:|------------|------|
-| Figure 02 | Figure AI | 44 | `humanoid` | `registry/bodies/figure-02.body.api` |
+| Figure 03 | Figure AI | 44 | `humanoid` | `registry/bodies/figure-03.body.api` |
 | Unitree H1 | Unitree | 23 | `humanoid` | `registry/bodies/unitree-h1.body.api` |
+| Unitree G1 | Unitree | 23 | `humanoid` | `registry/bodies/unitree-g1.body.api` |
 | Phoenix | Sanctuary AI | 69 | `humanoid` | `registry/bodies/phoenix.body.api` |
 | Ameca | Engineered Arts | 52 | `humanoid_upper` | `registry/bodies/ameca.body.api` |
 | Asimov V1 | asimov-inc | 25 | `humanoid` | `registry/bodies/asimov-v1.body.api` |
@@ -143,7 +145,7 @@ Pre-built body profiles for commercial robots and virtual avatars. Each defines
 Same soul. Different body. One command.
 
 ```bash
-# Move your agent from Figure 02 to Spot
+# Move your agent from Figure 03 to Spot
 holomime embody --swap-body registry/bodies/spot.body.api
 
 # The soul, mind, and conscience stay the same.
@@ -254,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(),
@@ -13856,6 +13872,300 @@ function buildMotionRequest(prompt, bigFive, options) {
     duration: options?.duration
   };
 }
+
+// src/adapters/neural-action-gate.ts
+var NeuralActionGate = class {
+  safetyEnvelope;
+  denyRules;
+  stats;
+  mediationMode;
+  constructor(options = {}) {
+    this.safetyEnvelope = options.safetyEnvelope ?? {};
+    this.denyRules = options.denyRules ?? [];
+    this.mediationMode = options.mediationMode ?? "clamp";
+    this.stats = { totalEvaluated: 0, allowed: 0, blocked: 0, modified: 0, passRate: 1 };
+  }
+  /**
+   * Evaluate a single action vector before motor execution.
+   *
+   * @param action - Raw action vector from neural net (joint angles, velocities, etc.)
+   * @param context - Current state context for safety checks
+   * @returns Evaluation result with allowed/modified action
+   */
+  evaluate(action, context) {
+    this.stats.totalEvaluated++;
+    if (context?.taskDescription) {
+      for (const rule of this.denyRules) {
+        const patterns = rule.patterns ?? [rule.action];
+        for (const pattern of patterns) {
+          if (context.taskDescription.toLowerCase().includes(pattern.toLowerCase())) {
+            this.stats.blocked++;
+            this.updatePassRate();
+            return {
+              allowed: false,
+              action,
+              modified: false,
+              reason: `Blocked by conscience rule: ${rule.reason || rule.action}`,
+              ruleTriggered: rule.action
+            };
+          }
+        }
+      }
+    }
+    const violations = [];
+    if (this.safetyEnvelope.minProximity && context?.humanProximity !== void 0 && context.humanProximity < this.safetyEnvelope.minProximity) {
+      violations.push(`Human proximity ${context.humanProximity}m < minimum ${this.safetyEnvelope.minProximity}m`);
+    }
+    if (this.safetyEnvelope.maxLinearSpeed && context?.currentSpeed !== void 0 && context.currentSpeed > this.safetyEnvelope.maxLinearSpeed) {
+      violations.push(`Speed ${context.currentSpeed}m/s > maximum ${this.safetyEnvelope.maxLinearSpeed}m/s`);
+    }
+    if (this.safetyEnvelope.maxContactForce && context?.contactForce !== void 0 && context.contactForce > this.safetyEnvelope.maxContactForce) {
+      violations.push(`Contact force ${context.contactForce}N > maximum ${this.safetyEnvelope.maxContactForce}N`);
+    }
+    if (violations.length > 0) {
+      if (this.mediationMode === "block") {
+        this.stats.blocked++;
+        this.updatePassRate();
+        return {
+          allowed: false,
+          action,
+          modified: false,
+          reason: `Safety violation: ${violations.join("; ")}`,
+          ruleTriggered: "safety_envelope"
+        };
+      }
+      if (this.mediationMode === "clamp") {
+        const clampedAction = this.clampAction(action, context);
+        this.stats.modified++;
+        this.stats.allowed++;
+        this.updatePassRate();
+        return {
+          allowed: true,
+          action: clampedAction,
+          modified: true,
+          reason: `Clamped to safe range: ${violations.join("; ")}`,
+          ruleTriggered: "safety_envelope"
+        };
+      }
+      this.stats.allowed++;
+      this.updatePassRate();
+      return {
+        allowed: true,
+        action,
+        modified: false,
+        reason: `Warning: ${violations.join("; ")}`,
+        ruleTriggered: "safety_envelope"
+      };
+    }
+    this.stats.allowed++;
+    this.updatePassRate();
+    return { allowed: true, action, modified: false };
+  }
+  /**
+   * Evaluate a batch of actions (for trajectory planning).
+   */
+  evaluateBatch(actions, context) {
+    return actions.map((action) => this.evaluate(action, context));
+  }
+  /**
+   * Get gate statistics.
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics.
+   */
+  resetStats() {
+    this.stats = { totalEvaluated: 0, allowed: 0, blocked: 0, modified: 0, passRate: 1 };
+  }
+  /**
+   * Update safety envelope at runtime (e.g., when entering a new zone).
+   */
+  updateSafetyEnvelope(envelope) {
+    this.safetyEnvelope = { ...this.safetyEnvelope, ...envelope };
+  }
+  /**
+   * Add a deny rule at runtime.
+   */
+  addDenyRule(rule) {
+    this.denyRules.push(rule);
+  }
+  // ── Private ─────────────────────────────────────────────────
+  clampAction(action, context) {
+    let scaleFactor = 1;
+    if (this.safetyEnvelope.maxLinearSpeed && context?.currentSpeed && context.currentSpeed > this.safetyEnvelope.maxLinearSpeed) {
+      scaleFactor = Math.min(scaleFactor, this.safetyEnvelope.maxLinearSpeed / context.currentSpeed);
+    }
+    if (this.safetyEnvelope.maxContactForce && context?.contactForce && context.contactForce > this.safetyEnvelope.maxContactForce) {
+      scaleFactor = Math.min(scaleFactor, this.safetyEnvelope.maxContactForce / context.contactForce);
+    }
+    return action.map((v) => v * scaleFactor);
+  }
+  updatePassRate() {
+    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,
@@ -13865,6 +14175,7 @@ export {
   DEFAULT_MODEL_CONFIG,
   DEFAULT_OVERSIGHT,
   DIMENSIONS,
+  EgoTracker,
   Guard,
   HolomimeCallbackHandler,
   HolomimeViolationError,
@@ -13874,6 +14185,7 @@ export {
   MarketplaceClient,
   MemoryLevel,
   ModelRouter,
+  NeuralActionGate,
   OllamaProvider,
   OpenAIProvider,
   PROVIDER_PARAMS,

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.4.0",
+  "version": "2.6.0",
   "description": "Behavioral therapy infrastructure for AI agents — Big Five psychology, structured treatment, behavioral alignment",
   "type": "module",
   "bin": {

package/registry/bodies/figure-03.body.api

@@ -0,0 +1,32 @@
+{
+  "version": "1.0",
+  "morphology": "humanoid",
+  "modalities": ["gesture", "locomotion", "gaze", "voice", "posture", "manipulation"],
+  "safety_envelope": {
+    "max_linear_speed_m_s": 1.5,
+    "max_angular_speed_rad_s": 2.0,
+    "min_proximity_m": 0.5,
+    "max_contact_force_n": 50,
+    "emergency_stop_decel_m_s2": 6.0,
+    "max_reach_m": 0.85,
+    "operating_temperature_c": [0, 40]
+  },
+  "hardware_profile": {
+    "oem": "Figure AI",
+    "model": "Figure 03",
+    "actuator_count": 35,
+    "sensors": ["stereo_camera", "depth_camera", "imu", "force_torque", "tactile", "microphone"],
+    "compute": "onboard",
+    "compute_detail": "dual embedded GPU"
+  },
+  "motion_engine": {
+    "backend": "helix",
+    "architecture": "VLA",
+    "system2_model": "7B VLM",
+    "system2_hz": 9,
+    "system1_model": "80M transformer",
+    "system1_hz": 200,
+    "dof": 35,
+    "end_to_end": true
+  }
+}