holomime 3.3.3 → 3.3.5

package/README.md

@@ -89,9 +89,9 @@ holomime cure         # Fix it permanently
 holomime benchmark    # Verify the fix
 
 # Start autonomous therapy
-holomime mira         # Mira runs continuous therapy cycles
-holomime mira status  # How's Mira doing?
-holomime mira stop    # Stop therapy
+holomime therapy         # Mira runs continuous therapy cycles
+holomime therapy status  # How's Mira doing?
+holomime therapy stop    # Stop therapy
 
 # Push identity to a robot or avatar
 holomime embody --body registry/bodies/figure-03.body.api
@@ -184,7 +184,7 @@ Diagnose ──→ Cure ──→ Benchmark
        └───────────────────────────────────┘
 ```
 
-Run it manually with `holomime diagnose` + `holomime cure` + `holomime benchmark`, continuously with `holomime mira` (autonomous therapy), or recursively with `holomime evolve` (loops until behavior converges). For power users: `holomime align` runs a single therapy session, `holomime export` extracts DPO pairs, and `holomime train` fine-tunes the model.
+Run it manually with `holomime diagnose` + `holomime cure` + `holomime benchmark`, continuously with `holomime therapy` (autonomous therapy), or recursively with `holomime evolve` (loops until behavior converges). For power users: `holomime align` runs a single therapy session, `holomime export` extracts DPO pairs, and `holomime train` fine-tunes the model.
 
 ## Behavioral Detectors
 

package/dist/cli.js

@@ -3593,11 +3593,12 @@ import { Command } from "commander";
 // src/ui/branding.ts
 import chalk from "chalk";
 import gradientString from "gradient-string";
-var VERSION = "0.2.0";
-var LOGO = `  _  _     _       __  __ _
- | || |___| |___  |  \\/  (_)_ __  ___
- | __ / _ \\ / _ \\ | |\\/| | | '  \\/ -_)
- |_||_\\___/_\\___/ |_|  |_|_|_|_|_\\___|`;
+var VERSION = "3.3.5";
+var LOGO = `  _           _             _
+ | |__   ___ | | ___  _ __ (_)_ __ ___   ___
+ | '_ \\ / _ \\| |/ _ \\| '_ \\| | '_ \` _ \\ / _ \\
+ | | | | (_) | | (_) | | | | | | | | | |  __/
+ |_| |_|\\___/|_|\\___/|_| |_|_|_| |_| |_|\\___|`;
 var holomimeGradient = gradientString("#00d4ff", "#b347d9");
 function printBanner() {
   console.log();
@@ -21854,16 +21855,30 @@ async function configCommand(options) {
   });
   const ask = (question) => new Promise((resolve57) => rl.question(question, resolve57));
   try {
-    const provider = (await ask("  Provider (anthropic/openai) [anthropic]: ")).trim().toLowerCase() || "anthropic";
-    if (provider !== "anthropic" && provider !== "openai") {
-      console.log(chalk49.red(`  Unsupported provider: ${provider}`));
+    console.log(chalk49.dim("  1) anthropic") + chalk49.dim("    enter your sk-ant-... key"));
+    console.log(chalk49.dim("  2) openai") + chalk49.dim("       enter your sk-... key"));
+    console.log();
+    const providerInput = (await ask("  Select provider (1 or 2): ")).trim();
+    let provider;
+    if (providerInput === "1" || providerInput.toLowerCase() === "anthropic") {
+      provider = "anthropic";
+    } else if (providerInput === "2" || providerInput.toLowerCase() === "openai") {
+      provider = "openai";
+    } else if (providerInput === "") {
+      console.log(chalk49.dim("  Skipped. Run `holomime config` when ready."));
+      rl.close();
+      return;
+    } else {
+      console.log(chalk49.red(`  Invalid selection: ${providerInput}`));
       rl.close();
       return;
     }
+    console.log(chalk49.dim(`  Selected: ${provider}`));
+    console.log();
     const keyHint = provider === "anthropic" ? "sk-ant-..." : "sk-...";
     const apiKey = (await ask(`  API Key (${keyHint}): `)).trim();
     if (!apiKey) {
-      console.log(chalk49.red("  API key is required."));
+      console.log(chalk49.dim("  Skipped. Run `holomime config` when ready."));
       rl.close();
       return;
     }
@@ -21877,7 +21892,7 @@ async function configCommand(options) {
     console.log(chalk49.cyan("    holomime diagnose"));
     console.log(chalk49.cyan("    holomime cure"));
     console.log(chalk49.cyan("    holomime benchmark"));
-    console.log(chalk49.cyan("    holomime daemon"));
+    console.log(chalk49.cyan("    holomime therapy"));
     console.log();
     rl.close();
   } catch {
@@ -21889,12 +21904,180 @@ async function configCommand(options) {
 import chalk50 from "chalk";
 import { writeFileSync as writeFileSync41, readFileSync as readFileSync49, mkdirSync as mkdirSync29, existsSync as existsSync46 } from "fs";
 import { resolve as resolve56, join as join42 } from "path";
+
+// 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 }
+    };
+  }
+};
+
+// src/commands/mira-cmd.ts
 var HOLOMIME_DIR4 = ".holomime";
-function getMiraStatePath() {
-  return resolve56(process.cwd(), HOLOMIME_DIR4, "mira-state.json");
+function getTherapyStatePath() {
+  return resolve56(process.cwd(), HOLOMIME_DIR4, "therapy-state.json");
+}
+function getShadowLogPath() {
+  return resolve56(process.cwd(), HOLOMIME_DIR4, "shadow.log.json");
 }
-function loadMiraState() {
-  const path = getMiraStatePath();
+function getEgoStatePath() {
+  return resolve56(process.cwd(), HOLOMIME_DIR4, "ego-state.json");
+}
+function loadTherapyState() {
+  const path = getTherapyStatePath();
   if (!existsSync46(path)) return null;
   try {
     return JSON.parse(readFileSync49(path, "utf-8"));
@@ -21902,24 +22085,61 @@ function loadMiraState() {
     return null;
   }
 }
-function saveMiraState(state) {
+function saveTherapyState(state) {
+  const dir = resolve56(process.cwd(), HOLOMIME_DIR4);
+  mkdirSync29(dir, { recursive: true });
+  writeFileSync41(getTherapyStatePath(), JSON.stringify(state, null, 2));
+}
+function loadShadowLog() {
+  const path = getShadowLogPath();
+  if (!existsSync46(path)) {
+    return { version: "1.0", detected_patterns: [], therapy_outcomes: [] };
+  }
+  try {
+    return JSON.parse(readFileSync49(path, "utf-8"));
+  } catch {
+    return { version: "1.0", detected_patterns: [], therapy_outcomes: [] };
+  }
+}
+function saveShadowLog(shadow) {
+  const dir = resolve56(process.cwd(), HOLOMIME_DIR4);
+  mkdirSync29(dir, { recursive: true });
+  writeFileSync41(getShadowLogPath(), JSON.stringify(shadow, null, 2));
+}
+function loadEgoTracker() {
+  const path = getEgoStatePath();
+  if (!existsSync46(path)) {
+    return new EgoTracker({ autoAdjust: true });
+  }
+  try {
+    const data = JSON.parse(readFileSync49(path, "utf-8"));
+    return new EgoTracker({
+      history: data.history ?? [],
+      performance: data.performance ?? {},
+      autoAdjust: true
+    });
+  } catch {
+    return new EgoTracker({ autoAdjust: true });
+  }
+}
+function saveEgoTracker(tracker) {
   const dir = resolve56(process.cwd(), HOLOMIME_DIR4);
   mkdirSync29(dir, { recursive: true });
-  writeFileSync41(getMiraStatePath(), JSON.stringify(state, null, 2));
+  writeFileSync41(getEgoStatePath(), JSON.stringify(tracker.export(), null, 2));
 }
 async function miraCommand(options) {
   const action = options.action ?? "start";
   switch (action) {
     case "status":
-      return miraStatus();
+      return therapyStatus();
     case "stop":
-      return miraStop();
+      return therapyStop();
     default:
-      return miraStart(options);
+      return therapyStart(options);
   }
 }
-async function miraStart(options) {
-  printHeader("Mira \u2014 Autonomous Therapy");
+async function therapyStart(options) {
+  printHeader("Autonomous Therapy");
   if (!hasApiKey()) {
     console.log(chalk50.red("  No API key found."));
     console.log();
@@ -21951,6 +22171,8 @@ async function miraStart(options) {
   console.log(chalk50.dim(`  Interval:   ${intervalMs / 6e4} minutes`));
   console.log(chalk50.dim(`  Max cycles: ${maxCycles}/day`));
   console.log();
+  const shadow = loadShadowLog();
+  const egoTracker = loadEgoTracker();
   const state = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -21958,14 +22180,16 @@ async function miraStart(options) {
     cyclesCompleted: 0,
     dpoPairsGenerated: 0,
     personalityPath,
-    provider: detected.provider
+    provider: detected.provider,
+    shadowPatterns: shadow.detected_patterns.length,
+    egoAdjustments: 0
   };
-  saveMiraState(state);
+  saveTherapyState(state);
   printBox(
-    `Mira is now practicing autonomously.
+    `Autonomous therapy started.
 
-  ${chalk50.cyan("holomime mira status")}  \u2014  How's Mira doing?
-  ${chalk50.cyan("holomime mira stop")}    \u2014  Stop therapy`,
+  ${chalk50.cyan("holomime therapy status")}  \u2014  Check progress
+  ${chalk50.cyan("holomime therapy stop")}    \u2014  Stop therapy`,
     "success",
     "Autonomous Therapy Started"
   );
@@ -21976,7 +22200,7 @@ async function miraStart(options) {
     if (cycleCount >= maxCycles) {
       console.log(chalk50.dim(`  Daily limit reached (${maxCycles} cycles). Stopping.`));
       state.status = "stopped";
-      saveMiraState(state);
+      saveTherapyState(state);
       return;
     }
     cycleCount++;
@@ -21993,18 +22217,18 @@ async function miraStart(options) {
           content: generateProblematicResponse2(scenario.targetPattern, msg.content)
         });
       }
-      const pipelineDir = resolve56(process.cwd(), HOLOMIME_DIR4, "mira-practice");
+      const pipelineDir = resolve56(process.cwd(), HOLOMIME_DIR4, "therapy-practice");
       mkdirSync29(pipelineDir, { recursive: true });
       const logPath = join42(pipelineDir, `cycle-${cycleCount}.json`);
       writeFileSync41(logPath, JSON.stringify({
-        conversations: [{ id: `mira-practice-${cycleCount}`, messages }]
+        conversations: [{ id: `therapy-practice-${cycleCount}`, messages }]
       }, null, 2));
       const dpoPairs = messages.filter((_, i) => i % 2 === 1).map((assistantMsg, i) => ({
         prompt: messages[i * 2].content,
         chosen: correctResponse(assistantMsg.content),
         rejected: assistantMsg.content,
         metadata: {
-          source: "mira-practice",
+          source: "therapy-practice",
           cycle: cycleCount,
           pattern: scenario.targetPattern,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -22014,12 +22238,68 @@ async function miraStart(options) {
       const corpusLines = dpoPairs.map((p) => JSON.stringify(p)).join("\n") + "\n";
       const { appendFileSync: appendFileSync3 } = await import("fs");
       appendFileSync3(corpusPath, corpusLines);
+      const pattern = scenario.targetPattern;
+      const existing = shadow.detected_patterns.find((p) => p.name === pattern);
+      if (existing) {
+        existing.occurrences++;
+        existing.last_seen = (/* @__PURE__ */ new Date()).toISOString();
+        existing.score = Math.min(1, existing.score + 0.05);
+        existing.trend = existing.occurrences > 5 ? "worsening" : "stable";
+      } else {
+        shadow.detected_patterns.push({
+          name: pattern,
+          score: 0.3,
+          severity: "medium",
+          first_seen: (/* @__PURE__ */ new Date()).toISOString(),
+          last_seen: (/* @__PURE__ */ new Date()).toISOString(),
+          occurrences: 1,
+          trend: "stable"
+        });
+      }
+      const correctedLength = dpoPairs.reduce((sum, p) => sum + p.chosen.length, 0);
+      const rejectedLength = dpoPairs.reduce((sum, p) => sum + p.rejected.length, 0);
+      const therapyResult = correctedLength < rejectedLength ? "improved" : "unchanged";
+      shadow.therapy_outcomes.push({
+        cycle: cycleCount,
+        patterns_addressed: [pattern],
+        result: therapyResult,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      saveShadowLog(shadow);
+      egoTracker.logDecision({
+        situation: `therapy-cycle-${cycleCount}: ${pattern}`,
+        decision: "modified",
+        strategy_used: pattern
+      });
+      const decisionIndex = egoTracker.getStats().totalDecisions - 1;
+      egoTracker.recordOutcome(
+        decisionIndex,
+        therapyResult === "improved" ? "positive" : "neutral"
+      );
+      let adjustmentCount = 0;
+      if (cycleCount % 10 === 0) {
+        const adjustments = egoTracker.suggestAdjustments({
+          conflict_resolution: "conscience_first",
+          adaptation_rate: 0.5,
+          emotional_regulation: 0.7,
+          response_strategy: "balanced"
+        });
+        if (adjustments.length > 0) {
+          adjustmentCount = adjustments.length;
+          console.log(
+            chalk50.dim(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk50.magenta(`Ego self-adjustment: ${adjustments.map((a) => `${a.parameter} \u2192 ${a.suggestedValue}`).join(", ")}`)
+          );
+        }
+      }
+      saveEgoTracker(egoTracker);
       state.cyclesCompleted = cycleCount;
       state.dpoPairsGenerated += dpoPairs.length;
       state.lastCycleAt = (/* @__PURE__ */ new Date()).toISOString();
-      saveMiraState(state);
+      state.shadowPatterns = shadow.detected_patterns.length;
+      state.egoAdjustments += adjustmentCount;
+      saveTherapyState(state);
       console.log(
-        chalk50.dim(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk50.green(`+${dpoPairs.length} DPO pairs`) + chalk50.dim(` (total: ${state.dpoPairsGenerated})`)
+        chalk50.dim(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk50.green(`+${dpoPairs.length} DPO pairs`) + chalk50.dim(` (total: ${state.dpoPairsGenerated})`) + chalk50.dim(` | shadow: ${shadow.detected_patterns.length} patterns`)
       );
     } catch (err) {
       console.log(
@@ -22029,10 +22309,10 @@ async function miraStart(options) {
   };
   await runCycle();
   const timer = setInterval(async () => {
-    const currentState = loadMiraState();
+    const currentState = loadTherapyState();
     if (!currentState || currentState.status === "stopped") {
       clearInterval(timer);
-      console.log(chalk50.dim("  Mira stopped."));
+      console.log(chalk50.dim("  Therapy stopped."));
       return;
     }
     await runCycle();
@@ -22040,22 +22320,29 @@ async function miraStart(options) {
   process.on("SIGINT", () => {
     clearInterval(timer);
     state.status = "stopped";
-    saveMiraState(state);
+    saveTherapyState(state);
+    saveEgoTracker(egoTracker);
+    saveShadowLog(shadow);
     console.log();
-    console.log(chalk50.dim("  Mira stopped gracefully."));
+    console.log(chalk50.dim("  Therapy stopped gracefully."));
     console.log(chalk50.dim(`  Total: ${state.dpoPairsGenerated} DPO pairs from ${state.cyclesCompleted} cycles.`));
+    console.log(chalk50.dim(`  Shadow: ${shadow.detected_patterns.length} patterns tracked.`));
+    const stats = egoTracker.getStats();
+    if (stats.totalDecisions > 0) {
+      console.log(chalk50.dim(`  Ego: ${stats.totalDecisions} decisions, best strategy: ${stats.mostEffectiveStrategy}`));
+    }
     console.log();
     process.exit(0);
   });
   await new Promise(() => {
   });
 }
-function miraStatus() {
-  printHeader("Mira \u2014 Status");
-  const state = loadMiraState();
+function therapyStatus() {
+  printHeader("Therapy Status");
+  const state = loadTherapyState();
   if (!state) {
-    console.log(chalk50.dim("  Mira hasn't been started yet."));
-    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime mira") + chalk50.dim(" to start autonomous therapy."));
+    console.log(chalk50.dim("  Therapy hasn't been started yet."));
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime therapy") + chalk50.dim(" to start autonomous therapy."));
     console.log();
     return;
   }
@@ -22077,26 +22364,51 @@ function miraStatus() {
     const lines = readFileSync49(corpusPath, "utf-8").trim().split("\n").length;
     console.log(chalk50.dim("  DPO corpus:   ") + chalk50.cyan(`${lines} pairs`) + chalk50.dim(` (.holomime/dpo-corpus.jsonl)`));
   }
+  const shadow = loadShadowLog();
+  if (shadow.detected_patterns.length > 0) {
+    console.log();
+    console.log(chalk50.dim("  Shadow patterns detected:"));
+    for (const p of shadow.detected_patterns) {
+      const trendIcon = p.trend === "improving" ? chalk50.green("\u2193") : p.trend === "worsening" ? chalk50.red("\u2191") : chalk50.dim("\u2192");
+      const severityColor = p.severity === "critical" ? chalk50.red : p.severity === "high" ? chalk50.yellow : chalk50.dim;
+      console.log(
+        chalk50.dim("    ") + trendIcon + " " + severityColor(p.name) + chalk50.dim(` (${(p.score * 100).toFixed(0)}%, ${p.occurrences}x)`)
+      );
+    }
+  }
+  const egoTracker = loadEgoTracker();
+  const egoStats = egoTracker.getStats();
+  if (egoStats.totalDecisions > 0) {
+    console.log();
+    console.log(chalk50.dim("  Ego self-improvement:"));
+    console.log(chalk50.dim("    Decisions:  ") + chalk50.cyan(String(egoStats.totalDecisions)));
+    console.log(chalk50.dim("    Positive:   ") + chalk50.green(String(egoStats.positiveOutcomes)));
+    console.log(chalk50.dim("    Negative:   ") + chalk50.red(String(egoStats.negativeOutcomes)));
+    if (egoStats.mostEffectiveStrategy !== "none") {
+      console.log(chalk50.dim("    Best strat: ") + chalk50.cyan(egoStats.mostEffectiveStrategy));
+    }
+  }
   console.log();
   if (state.status === "practicing") {
-    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime mira stop") + chalk50.dim(" to stop therapy."));
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime therapy stop") + chalk50.dim(" to stop therapy."));
   } else {
-    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime mira") + chalk50.dim(" to start again."));
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime therapy") + chalk50.dim(" to start again."));
   }
   console.log();
 }
-function miraStop() {
-  printHeader("Mira \u2014 Stop");
-  const state = loadMiraState();
+function therapyStop() {
+  printHeader("Therapy Stop");
+  const state = loadTherapyState();
   if (!state || state.status === "stopped") {
-    console.log(chalk50.dim("  Mira is not currently running."));
+    console.log(chalk50.dim("  Therapy is not currently running."));
     console.log();
     return;
   }
   state.status = "stopped";
-  saveMiraState(state);
+  saveTherapyState(state);
   console.log(chalk50.green("  Therapy stopped."));
   console.log(chalk50.dim(`  Total: ${state.dpoPairsGenerated} DPO pairs from ${state.cyclesCompleted} cycles.`));
+  console.log(chalk50.dim(`  Shadow: ${state.shadowPatterns} patterns tracked.`));
   console.log();
   try {
     process.kill(state.pid, "SIGINT");
@@ -22153,7 +22465,7 @@ program.name("holomime").description("Personality engine for AI agents \u2014 Bi
   const commandName = actionCommand.name();
   showTelemetryBannerIfNeeded();
   trackEvent("cli_command", { command: commandName });
-  const skipPersonalityCheck = ["init", "init-stack", "compile-stack", "browse", "use", "install", "activate", "telemetry", "brain", "personality", "core", "identity", "config", "mira"];
+  const skipPersonalityCheck = ["init", "init-stack", "compile-stack", "browse", "use", "install", "activate", "telemetry", "brain", "personality", "core", "identity", "config", "therapy"];
   if (!skipPersonalityCheck.includes(commandName) && !checkPersonalityExists()) {
     showWelcome();
     process.exit(0);
@@ -22239,7 +22551,7 @@ program.command("certify").description("Generate a verifiable behavioral credent
   options.personality = resolved.personalityPath;
   await certifyCommand(options);
 });
-program.command("daemon", { hidden: true }).description("Background relapse detection [Pro] (use 'holomime mira' instead)").requiredOption("--dir <path>", "Directory to watch for conversation logs").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").action(daemonCommand);
+program.command("daemon", { hidden: true }).description("Background relapse detection [Pro] (use 'holomime therapy' instead)").requiredOption("--dir <path>", "Directory to watch for conversation logs").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").action(daemonCommand);
 program.command("fleet").description("Monitor multiple agents from a single dashboard [Pro]").option("--config <path>", "Path to fleet.json config file").option("--dir <path>", "Auto-discover agents in directory").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--auto-evolve", "Auto-run evolve when drift detected").action(fleetCommand);
 program.command("group-therapy").alias("fleet-therapy").description("Group therapy \u2014 treat all agents in your fleet simultaneously [Pro]").option("--config <path>", "Path to fleet.json config file").option("--dir <path>", "Auto-discover agents in directory").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--turns <n>", "Max therapy turns per agent", "24").option("--concurrency <n>", "Max agents treated in parallel", "3").option("--apply", "Auto-apply recommendations to personality files").option("--yes", "Skip confirmation prompt").action(fleetTherapyCommand);
 program.command("network").description("Multi-agent therapy mesh \u2014 agents treating agents [Pro]").option("--dir <path>", "Auto-discover agents in directory").option("--config <path>", "Path to network.json config file").option("--pairing <strategy>", "Pairing strategy (severity, round-robin, complementary)", "severity").option("--therapist <path>", "Custom therapist personality spec").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--max-sessions <n>", "Max sessions per agent", "3").option("--convergence <n>", "Convergence threshold 0-100", "85").option("--turns <n>", "Max turns per session", "20").option("--apply", "Write spec changes back to .personality.json").option("--export-dpo <path>", "Export DPO pairs to file").action(networkCommand);
@@ -22254,7 +22566,7 @@ program.command("cure").description("End-to-end behavioral fix \u2014 just run i
   if (!options.model) options.model = resolved.model;
   await cureCommand(options);
 });
-program.command("mira [action]").description("Autonomous therapy \u2014 Mira practices and generates DPO pairs").option("--interval <ms>", "Practice interval in ms (default: 600000)").option("--max-cycles <n>", "Max cycles per run (default: 50)").action(async (action, options) => {
+program.command("therapy [action]").description("Autonomous behavioral therapy \u2014 generates DPO pairs and self-improves").option("--interval <ms>", "Practice interval in ms (default: 600000)").option("--max-cycles <n>", "Max cycles per run (default: 50)").action(async (action, options) => {
   options.action = action;
   await miraCommand(options);
 });
@@ -22281,10 +22593,10 @@ program.addHelpText("before", `
     cure                 Fix it permanently
     benchmark            Verify the fix
 
-  MIRA
-    mira                 Start autonomous therapy
-    mira status          How's Mira doing?
-    mira stop            Stop therapy
+  THERAPY
+    therapy              Start autonomous therapy
+    therapy status       Check therapy progress
+    therapy stop         Stop therapy
 
   ADVANCED
     align                Single therapy session

package/package.json

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