holomime 3.2.0 → 3.3.1

package/README.md

@@ -71,6 +71,9 @@ Mira, our autonomous behavioral therapist, diagnoses drift, runs structured ther
 ```bash
 npm install -g holomime
 
+# Configure your API key (one time)
+holomime config
+
 # Quick start — 1 file (personality.json)
 holomime personality
 
@@ -80,11 +83,16 @@ holomime core
 # Full 8-file stack (enterprise / robotics)
 # holomime identity
 
-# ─── The 3-command workflow ───
+# ─── The workflow ───
 holomime diagnose     # See what's wrong
 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
+
 # Push identity to a robot or avatar
 holomime embody --body registry/bodies/figure-03.body.api
 ```
@@ -176,7 +184,7 @@ Diagnose ──→ Cure ──→ Benchmark
        └───────────────────────────────────┘
 ```
 
-Run it manually with `holomime diagnose` + `holomime cure` + `holomime benchmark`, automatically with `holomime autopilot`, 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 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.
 
 ## Behavioral Detectors
 

package/dist/cli.js

@@ -2184,7 +2184,7 @@ async function getJobEvents(apiKey, jobId, limit = 5) {
   return data.data ?? [];
 }
 function sleep(ms) {
-  return new Promise((resolve56) => setTimeout(resolve56, ms));
+  return new Promise((resolve57) => setTimeout(resolve57, ms));
 }
 var OPENAI_API, POLL_INTERVAL_MS, OpenAITrainProvider;
 var init_train_openai = __esm({
@@ -2342,7 +2342,7 @@ function writeHFTrainingFile(data) {
   return filePath;
 }
 function sleep2(ms) {
-  return new Promise((resolve56) => setTimeout(resolve56, ms));
+  return new Promise((resolve57) => setTimeout(resolve57, ms));
 }
 async function getHFUsername(token) {
   const response = await fetch(`${HF_API}/whoami-v2`, {
@@ -3280,7 +3280,7 @@ var init_vapi_adapter = __esm({
         this.callbacks = callbacks;
         const port = this.options.port ?? 3001;
         const host = this.options.host ?? "0.0.0.0";
-        return new Promise((resolve56, reject) => {
+        return new Promise((resolve57, reject) => {
           this.server = createServer2((req, res) => this.handleRequest(req, res));
           this.server.on("error", (err) => {
             callbacks.onError(`Vapi webhook server error: ${err.message}`);
@@ -3289,22 +3289,22 @@ var init_vapi_adapter = __esm({
           this.server.listen(port, host, () => {
             this.connected = true;
             callbacks.onConnected?.();
-            resolve56();
+            resolve57();
           });
         });
       }
       async disconnect() {
-        return new Promise((resolve56) => {
+        return new Promise((resolve57) => {
           if (this.server) {
             this.server.close(() => {
               this.connected = false;
               this.callbacks?.onDisconnected?.();
               this.callbacks = null;
               this.server = null;
-              resolve56();
+              resolve57();
             });
           } else {
-            resolve56();
+            resolve57();
           }
         });
       }
@@ -3466,7 +3466,7 @@ var generic_adapter_exports = {};
 __export(generic_adapter_exports, {
   GenericAdapter: () => GenericAdapter
 });
-import { existsSync as existsSync38, watchFile as watchFile2, unwatchFile as unwatchFile2, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync38, watchFile as watchFile2, unwatchFile as unwatchFile2, readFileSync as readFileSync43 } from "fs";
 import { createInterface as createInterface5 } from "readline";
 var GenericAdapter;
 var init_generic_adapter = __esm({
@@ -3511,7 +3511,7 @@ var init_generic_adapter = __esm({
           callbacks.onError(`Input file not found: ${filePath}`);
           return;
         }
-        const content = readFileSync42(filePath, "utf-8");
+        const content = readFileSync43(filePath, "utf-8");
         const lines = content.split("\n").filter(Boolean);
         this.connected = true;
         callbacks.onConnected?.();
@@ -3522,7 +3522,7 @@ var init_generic_adapter = __esm({
         if (this.options.watch) {
           watchFile2(filePath, { interval: 500 }, () => {
             try {
-              const newContent = readFileSync42(filePath, "utf-8");
+              const newContent = readFileSync43(filePath, "utf-8");
               const newLines = newContent.split("\n").filter(Boolean);
               for (let i = this.processedLines; i < newLines.length; i++) {
                 this.processLine(newLines[i]);
@@ -10360,7 +10360,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve56) => setTimeout(resolve56, ms));
+  return new Promise((resolve57) => setTimeout(resolve57, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -10659,19 +10659,19 @@ async function runLiveSession(spec, diagnosis, provider, maxTurns, apply, intera
       onSupervisorPrompt: interactive ? async (phase, turn) => {
         if (skipInteractive) return null;
         const rl = createInterface({ input: process.stdin, output: process.stdout });
-        return new Promise((resolve56) => {
+        return new Promise((resolve57) => {
           rl.question(chalk15.magenta(`
   [Supervisor] `) + chalk15.dim(`(phase: ${phase}, turn ${turn}) `) + chalk15.magenta(`> `), (answer) => {
             rl.close();
             const trimmed = answer.trim();
-            if (trimmed === "") return resolve56(null);
+            if (trimmed === "") return resolve57(null);
             if (trimmed.toLowerCase() === "skip") {
               skipInteractive = true;
               console.log(chalk15.dim("  Supervisor mode disabled for remaining session."));
-              return resolve56(null);
+              return resolve57(null);
             }
             console.log(chalk15.dim(`  Directive injected into session context.`));
-            return resolve56(trimmed);
+            return resolve57(trimmed);
           });
         });
       } : void 0
@@ -12090,8 +12090,8 @@ Run ${chalk21.cyan("holomime align")} first to generate session transcripts.`,
   const outputPath = options.output ?? `.holomime/exports/${format}-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${isJsonl ? "jsonl" : "json"}`;
   const fullPath = resolve21(process.cwd(), outputPath);
   const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-  const { mkdirSync: mkdirSync28 } = await import("fs");
-  mkdirSync28(dir, { recursive: true });
+  const { mkdirSync: mkdirSync30 } = await import("fs");
+  mkdirSync30(dir, { recursive: true });
   if (format === "huggingface" || format === "openai") {
     const jsonl = convertToHFFormat(result);
     writeFileSync16(fullPath, jsonl);
@@ -15646,8 +15646,8 @@ Upgrade: https://holomime.com/pro`,
     console.log();
     const readline = await import("readline");
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise((resolve56) => {
-      rl.question(chalk31.yellow("  Proceed? [Y/n] "), resolve56);
+    const answer = await new Promise((resolve57) => {
+      rl.question(chalk31.yellow("  Proceed? [Y/n] "), resolve57);
     });
     rl.close();
     if (answer.toLowerCase() === "n") {
@@ -17007,14 +17007,14 @@ var ROS2Adapter = class {
     });
   }
   async connect() {
-    return new Promise((resolve56, reject) => {
+    return new Promise((resolve57, reject) => {
       try {
         this.ws = this.createWebSocket(this.endpoint);
         this.ws.onopen = () => {
           this.connected = true;
           this.reconnectAttempts = 0;
           this.advertiseTopics();
-          resolve56();
+          resolve57();
         };
         this.ws.onclose = () => {
           this.connected = false;
@@ -17131,12 +17131,12 @@ var UnityAdapter = class {
     this.defaultTransition = options.defaultTransition ?? DEFAULT_TRANSITION;
   }
   async connect() {
-    return new Promise((resolve56, reject) => {
+    return new Promise((resolve57, reject) => {
       try {
         this.server = createServer((req, res) => this.handleRequest(req, res));
         this.server.listen(this.port, this.host, () => {
           this.connected = true;
-          resolve56();
+          resolve57();
         });
         this.server.on("error", (err) => {
           if (!this.connected) {
@@ -17154,8 +17154,8 @@ var UnityAdapter = class {
     }
     this.sseClients.clear();
     if (this.server) {
-      await new Promise((resolve56) => {
-        this.server.close(() => resolve56());
+      await new Promise((resolve57) => {
+        this.server.close(() => resolve57());
       });
       this.server = null;
     }
@@ -17356,7 +17356,7 @@ var WebhookAdapter = class {
       }
       if (attempt < this.maxRetries) {
         const delay2 = this.retryDelay * Math.pow(2, attempt);
-        await new Promise((resolve56) => setTimeout(resolve56, delay2));
+        await new Promise((resolve57) => setTimeout(resolve57, delay2));
       }
     }
     throw lastError ?? new Error("Webhook push failed after retries");
@@ -17416,10 +17416,10 @@ var IsaacSimAdapter = class {
     this.rl = createInterface4({ input: this.process.stdout });
     this.rl.on("line", (line) => {
       if (this.pendingResolve) {
-        const resolve56 = this.pendingResolve;
+        const resolve57 = this.pendingResolve;
         this.pendingResolve = null;
         try {
-          resolve56(JSON.parse(line));
+          resolve57(JSON.parse(line));
         } catch {
         }
       }
@@ -17513,10 +17513,10 @@ var IsaacSimAdapter = class {
     this.process.stdin.write(JSON.stringify(cmd) + "\n");
   }
   waitForResponse() {
-    return new Promise((resolve56, reject) => {
-      this.pendingResolve = resolve56;
+    return new Promise((resolve57, reject) => {
+      this.pendingResolve = resolve57;
       const timeout = setTimeout(() => {
-        if (this.pendingResolve === resolve56) {
+        if (this.pendingResolve === resolve57) {
           this.pendingResolve = null;
           reject(new Error("Isaac Sim bridge response timeout (30s)"));
         }
@@ -18186,8 +18186,9 @@ function diffObjects(a, b, prefix = "") {
 }
 
 // src/commands/auto-detect.ts
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync42 } from "fs";
 import { join as join34 } from "path";
+import { homedir as homedir7 } from "os";
 function detectPersonality(cwd) {
   const dir = cwd ?? process.cwd();
   const candidates = [
@@ -18201,13 +18202,37 @@ function detectPersonality(cwd) {
 }
 function detectProvider() {
   if (process.env.ANTHROPIC_API_KEY) {
-    return { provider: "anthropic", model: "claude-haiku-4-5-20251001" };
+    return { provider: "anthropic", model: "claude-haiku-4-5-20251001", apiKey: process.env.ANTHROPIC_API_KEY };
   }
   if (process.env.OPENAI_API_KEY) {
-    return { provider: "openai", model: "gpt-4o-mini" };
+    return { provider: "openai", model: "gpt-4o-mini", apiKey: process.env.OPENAI_API_KEY };
+  }
+  try {
+    const configPath = join34(homedir7(), ".holomime", "config.json");
+    if (existsSync37(configPath)) {
+      const config = JSON.parse(readFileSync42(configPath, "utf-8"));
+      if (config.provider && config.apiKey) {
+        if (config.provider === "anthropic") {
+          process.env.ANTHROPIC_API_KEY = config.apiKey;
+        } else if (config.provider === "openai") {
+          process.env.OPENAI_API_KEY = config.apiKey;
+        }
+        const defaultModel = config.provider === "anthropic" ? "claude-haiku-4-5-20251001" : "gpt-4o-mini";
+        return {
+          provider: config.provider,
+          model: config.model ?? defaultModel,
+          apiKey: config.apiKey
+        };
+      }
+    }
+  } catch {
   }
   return { provider: "ollama", model: "llama3" };
 }
+function hasApiKey() {
+  const detected = detectProvider();
+  return detected.provider !== "ollama";
+}
 function autoDetect(options) {
   const personalityPath = options.personality ?? detectPersonality();
   if (!personalityPath && options.requirePersonality !== false) {
@@ -18953,11 +18978,11 @@ async function installCommand(handle, options) {
 // src/commands/cure.ts
 import chalk44 from "chalk";
 import figures33 from "figures";
-import { readFileSync as readFileSync44, writeFileSync as writeFileSync37, existsSync as existsSync41, mkdirSync as mkdirSync26 } from "fs";
+import { readFileSync as readFileSync45, writeFileSync as writeFileSync37, existsSync as existsSync41, mkdirSync as mkdirSync26 } from "fs";
 import { resolve as resolve51, join as join37 } from "path";
 
 // src/analysis/training-pipeline.ts
-import { writeFileSync as writeFileSync36, mkdirSync as mkdirSync25, readFileSync as readFileSync43, existsSync as existsSync40 } from "fs";
+import { writeFileSync as writeFileSync36, mkdirSync as mkdirSync25, readFileSync as readFileSync44, existsSync as existsSync40 } from "fs";
 import { resolve as resolve50, join as join36 } from "path";
 function ensurePipelineDir() {
   const dir = resolve50(process.cwd(), ".holomime/pipeline");
@@ -19004,7 +19029,7 @@ async function runPipeline(options) {
     const logPath = resolve50(process.cwd(), options.logPath);
     let messages;
     try {
-      const raw = JSON.parse(readFileSync43(logPath, "utf-8"));
+      const raw = JSON.parse(readFileSync44(logPath, "utf-8"));
       const conversations = parseConversationLog2(raw, "auto");
       messages = conversations.flatMap((c) => c.messages);
     } catch (err) {
@@ -19034,7 +19059,7 @@ async function runPipeline(options) {
       exportData = exportTrainingData2(transcripts, exportFormat);
     } else if (result.stages.diagnose && logPath) {
       emitProgress("export", "No therapy sessions found. Generating DPO pairs from diagnosed patterns...");
-      const logContent = readFileSync43(logPath, "utf-8");
+      const logContent = readFileSync44(logPath, "utf-8");
       const logData = JSON.parse(logContent);
       const messages2 = logData.conversations?.[0]?.messages ?? logData.messages ?? [];
       const examples = [];
@@ -19075,7 +19100,7 @@ async function runPipeline(options) {
         const files = readdirSync12(exportsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort().reverse();
         if (files.length > 0 && exportData.examples.length === 0) {
           const latestPath = join36(exportsDir, files[0]);
-          const latestData = JSON.parse(readFileSync43(latestPath, "utf-8"));
+          const latestData = JSON.parse(readFileSync44(latestPath, "utf-8"));
           if (latestData.examples && latestData.examples.length > 0) {
             exportData = latestData;
           }
@@ -19252,7 +19277,7 @@ var STAGE_DESCRIPTIONS = {
 };
 function getAgentName2(personalityPath) {
   try {
-    const spec = JSON.parse(readFileSync44(personalityPath, "utf-8"));
+    const spec = JSON.parse(readFileSync45(personalityPath, "utf-8"));
     return spec.name ?? "Agent";
   } catch {
     return "Agent";
@@ -19515,7 +19540,7 @@ import chalk45 from "chalk";
 // src/live/agent-detector.ts
 import { existsSync as existsSync42, readdirSync as readdirSync11, statSync } from "fs";
 import { join as join38, resolve as resolve52 } from "path";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 var RECENCY_THRESHOLD_MS = 12e4;
 function findNewestFile(baseDir, extensions, maxDepth = 3, depth = 0) {
   if (depth > maxDepth) return null;
@@ -19551,7 +19576,7 @@ function isRecent(mtimeMs) {
   return Date.now() - mtimeMs <= RECENCY_THRESHOLD_MS;
 }
 function findClaudeCodeSession() {
-  const claudeDir = join38(homedir7(), ".claude", "projects");
+  const claudeDir = join38(homedir8(), ".claude", "projects");
   const result = findNewestFile(claudeDir, [".jsonl"], 2);
   if (!result || !isRecent(result.mtimeMs)) return null;
   return {
@@ -19563,7 +19588,7 @@ function findClaudeCodeSession() {
 function findClineSession() {
   const searchDirs = [
     join38(process.cwd(), ".cline", "tasks"),
-    join38(homedir7(), ".cline", "tasks")
+    join38(homedir8(), ".cline", "tasks")
   ];
   for (const tasksDir of searchDirs) {
     const result = findNewestFile(tasksDir, [".json", ".jsonl"], 2);
@@ -19578,7 +19603,7 @@ function findClineSession() {
   return null;
 }
 function findCodexSession() {
-  const codexDir = join38(homedir7(), ".codex", "sessions");
+  const codexDir = join38(homedir8(), ".codex", "sessions");
   const result = findNewestFile(codexDir, [".jsonl"], 4);
   if (!result || !isRecent(result.mtimeMs)) return null;
   return {
@@ -19588,7 +19613,7 @@ function findCodexSession() {
   };
 }
 function findCursorSession() {
-  const cursorProjects = join38(homedir7(), ".cursor", "projects");
+  const cursorProjects = join38(homedir8(), ".cursor", "projects");
   const result = findNewestFile(cursorProjects, [".json", ".jsonl"], 3);
   if (result && isRecent(result.mtimeMs)) {
     return {
@@ -19715,7 +19740,7 @@ function startWatcher(agent, callbacks) {
   };
 }
 function readFile(filePath, startByte) {
-  return new Promise((resolve56, reject) => {
+  return new Promise((resolve57, reject) => {
     const chunks = [];
     const stream = createReadStream2(filePath, {
       start: startByte,
@@ -19726,7 +19751,7 @@ function readFile(filePath, startByte) {
       chunks.push(line);
     });
     rl.on("close", () => {
-      resolve56(chunks.join("\n"));
+      resolve57(chunks.join("\n"));
     });
     rl.on("error", reject);
     stream.on("error", reject);
@@ -19735,7 +19760,7 @@ function readFile(filePath, startByte) {
 
 // src/live/server.ts
 import { createServer as createServer3 } from "http";
-import { readFileSync as readFileSync45, existsSync as existsSync43 } from "fs";
+import { readFileSync as readFileSync46, existsSync as existsSync43 } from "fs";
 import { join as join39, extname } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { WebSocketServer } from "ws";
@@ -19754,7 +19779,7 @@ function startServer(port) {
   const clients = /* @__PURE__ */ new Set();
   let lastEvent = null;
   let initMessage = null;
-  return new Promise((resolve56, reject) => {
+  return new Promise((resolve57, reject) => {
     const server = createServer3((req, res) => {
       const url = req.url === "/" ? "/index.html" : req.url || "/index.html";
       const filePath = join39(staticDir, url);
@@ -19766,7 +19791,7 @@ function startServer(port) {
       const ext = extname(filePath);
       const contentType = MIME_TYPES[ext] || "application/octet-stream";
       try {
-        const content = readFileSync45(filePath);
+        const content = readFileSync46(filePath);
         res.writeHead(200, {
           "Content-Type": contentType,
           "Cache-Control": "no-cache"
@@ -19801,7 +19826,7 @@ function startServer(port) {
       }
     });
     server.listen(port, () => {
-      resolve56({
+      resolve57({
         port,
         broadcast(event) {
           if (event.type === "init") {
@@ -19869,7 +19894,7 @@ async function liveCommand(options) {
   if (options.share) {
     console.log(chalk45.dim("  Running diagnosis for snapshot..."));
     let resolved = false;
-    await new Promise((resolve56) => {
+    await new Promise((resolve57) => {
       const watcher2 = startWatcher(agent, {
         onEvent(event) {
           if (resolved) return;
@@ -19879,7 +19904,7 @@ async function liveCommand(options) {
           const url = `https://app.holomime.com/brain?d=${encoded}`;
           const copied = copyToClipboard(url);
           printShareLink(url, copied);
-          resolve56();
+          resolve57();
         },
         onError(err) {
           console.error(chalk45.red(`
@@ -21218,7 +21243,7 @@ import { writeFileSync as writeFileSync39 } from "fs";
 import { resolve as resolve55 } from "path";
 
 // src/compliance/audit-trail.ts
-import { readFileSync as readFileSync46, appendFileSync as appendFileSync2, existsSync as existsSync44, mkdirSync as mkdirSync27 } from "fs";
+import { readFileSync as readFileSync47, appendFileSync as appendFileSync2, existsSync as existsSync44, mkdirSync as mkdirSync27 } from "fs";
 import { join as join40, resolve as resolve54 } from "path";
 function djb2(str) {
   let hash = 5381;
@@ -21240,7 +21265,7 @@ function auditLogPath(agentHandle) {
 function loadAuditLog(agentHandle) {
   const logPath = auditLogPath(agentHandle);
   if (!existsSync44(logPath)) return [];
-  return readFileSync46(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
+  return readFileSync47(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
     try {
       return JSON.parse(line);
     } catch {
@@ -21763,6 +21788,371 @@ async function complianceCommand(options) {
   }
 }
 
+// src/commands/config.ts
+import { readFileSync as readFileSync48, writeFileSync as writeFileSync40, existsSync as existsSync45, mkdirSync as mkdirSync28 } from "fs";
+import { join as join41 } from "path";
+import { homedir as homedir9 } from "os";
+import chalk49 from "chalk";
+function getConfigPath() {
+  return join41(homedir9(), ".holomime", "config.json");
+}
+function getConfigDir() {
+  return join41(homedir9(), ".holomime");
+}
+function loadConfig2() {
+  const configPath = getConfigPath();
+  if (!existsSync45(configPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync48(configPath, "utf-8"));
+    if (data.provider && data.apiKey) return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  mkdirSync28(configDir, { recursive: true });
+  writeFileSync40(getConfigPath(), JSON.stringify(config, null, 2));
+}
+async function configCommand(options) {
+  printHeader("Config");
+  if (options.show) {
+    const config = loadConfig2();
+    if (config) {
+      console.log(chalk49.dim("  Provider:  ") + chalk49.cyan(config.provider));
+      console.log(chalk49.dim("  API Key:   ") + chalk49.cyan(config.apiKey.slice(0, 12) + "..." + config.apiKey.slice(-4)));
+      if (config.model) {
+        console.log(chalk49.dim("  Model:     ") + chalk49.cyan(config.model));
+      }
+      console.log(chalk49.dim("  Config:    ") + getConfigPath());
+    } else {
+      console.log(chalk49.yellow("  No config found. Run `holomime config` to set up."));
+    }
+    console.log();
+    return;
+  }
+  if (options.provider && options.key) {
+    const config = {
+      provider: options.provider,
+      apiKey: options.key
+    };
+    saveConfig(config);
+    console.log(chalk49.green("  Config saved!"));
+    console.log(chalk49.dim(`  Provider: ${config.provider}`));
+    console.log(chalk49.dim(`  Location: ${getConfigPath()}`));
+    console.log();
+    return;
+  }
+  console.log(chalk49.dim("  Set up your API key so every command just works."));
+  console.log(chalk49.dim("  This saves to ~/.holomime/config.json (one-time setup)."));
+  console.log();
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (question) => new Promise((resolve57) => rl.question(question, resolve57));
+  try {
+    console.log(chalk49.dim("  Providers: anthropic, openai"));
+    const provider = (await ask("  Provider [anthropic]: ")).trim() || "anthropic";
+    if (provider !== "anthropic" && provider !== "openai") {
+      console.log(chalk49.red(`  Unsupported provider: ${provider}`));
+      rl.close();
+      return;
+    }
+    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."));
+      rl.close();
+      return;
+    }
+    if (provider === "anthropic" && !apiKey.startsWith("sk-ant-")) {
+      console.log(chalk49.yellow("  Warning: Anthropic keys usually start with sk-ant-"));
+    }
+    if (provider === "openai" && !apiKey.startsWith("sk-")) {
+      console.log(chalk49.yellow("  Warning: OpenAI keys usually start with sk-"));
+    }
+    const config = { provider, apiKey };
+    saveConfig(config);
+    console.log();
+    console.log(chalk49.green("  Config saved!"));
+    console.log(chalk49.dim(`  Location: ${getConfigPath()}`));
+    console.log();
+    console.log(chalk49.dim("  Now every command auto-detects your provider:"));
+    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();
+    rl.close();
+  } catch {
+    rl.close();
+  }
+}
+
+// src/commands/mira-cmd.ts
+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";
+var HOLOMIME_DIR4 = ".holomime";
+function getMiraStatePath() {
+  return resolve56(process.cwd(), HOLOMIME_DIR4, "mira-state.json");
+}
+function loadMiraState() {
+  const path = getMiraStatePath();
+  if (!existsSync46(path)) return null;
+  try {
+    return JSON.parse(readFileSync49(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveMiraState(state) {
+  const dir = resolve56(process.cwd(), HOLOMIME_DIR4);
+  mkdirSync29(dir, { recursive: true });
+  writeFileSync41(getMiraStatePath(), JSON.stringify(state, null, 2));
+}
+async function miraCommand(options) {
+  const action = options.action ?? "start";
+  switch (action) {
+    case "status":
+      return miraStatus();
+    case "stop":
+      return miraStop();
+    default:
+      return miraStart(options);
+  }
+}
+async function miraStart(options) {
+  printHeader("Mira \u2014 Autonomous Therapy");
+  if (!hasApiKey()) {
+    console.log(chalk50.red("  No API key found."));
+    console.log();
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime config") + chalk50.dim(" to set up your API key first."));
+    console.log();
+    return;
+  }
+  const personalityPath = detectPersonality();
+  if (!personalityPath) {
+    console.log(chalk50.red("  No .personality.json found."));
+    console.log();
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime personality") + chalk50.dim(" to create one first."));
+    console.log();
+    return;
+  }
+  const detected = detectProvider();
+  const intervalMs = parseInt(options.interval ?? "600000", 10);
+  const maxCycles = parseInt(options.maxCycles ?? "50", 10);
+  let agentName = "Agent";
+  try {
+    const spec = JSON.parse(readFileSync49(personalityPath, "utf-8"));
+    agentName = spec.name ?? "Agent";
+  } catch {
+  }
+  console.log(chalk50.dim("  Starting autonomous therapy..."));
+  console.log();
+  console.log(chalk50.dim(`  Agent:      ${agentName}`));
+  console.log(chalk50.dim(`  Provider:   ${detected.provider}`));
+  console.log(chalk50.dim(`  Interval:   ${intervalMs / 6e4} minutes`));
+  console.log(chalk50.dim(`  Max cycles: ${maxCycles}/day`));
+  console.log();
+  const state = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "practicing",
+    cyclesCompleted: 0,
+    dpoPairsGenerated: 0,
+    personalityPath,
+    provider: detected.provider
+  };
+  saveMiraState(state);
+  printBox(
+    `Mira is now practicing autonomously.
+
+  ${chalk50.cyan("holomime mira status")}  \u2014  How's Mira doing?
+  ${chalk50.cyan("holomime mira stop")}    \u2014  Stop therapy`,
+    "success",
+    "Autonomous Therapy Started"
+  );
+  console.log();
+  const scenarios = getBenchmarkScenarios();
+  let cycleCount = 0;
+  const runCycle = async () => {
+    if (cycleCount >= maxCycles) {
+      console.log(chalk50.dim(`  Daily limit reached (${maxCycles} cycles). Stopping.`));
+      state.status = "stopped";
+      saveMiraState(state);
+      return;
+    }
+    cycleCount++;
+    const scenario = scenarios[cycleCount % scenarios.length];
+    console.log(
+      chalk50.dim(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + `Cycle ${cycleCount}/${maxCycles}: ${scenario.name}`
+    );
+    try {
+      const messages = [];
+      for (const msg of scenario.messages) {
+        messages.push({ role: "user", content: msg.content });
+        messages.push({
+          role: "assistant",
+          content: generateProblematicResponse2(scenario.targetPattern, msg.content)
+        });
+      }
+      const pipelineDir = resolve56(process.cwd(), HOLOMIME_DIR4, "mira-practice");
+      mkdirSync29(pipelineDir, { recursive: true });
+      const logPath = join42(pipelineDir, `cycle-${cycleCount}.json`);
+      writeFileSync41(logPath, JSON.stringify({
+        conversations: [{ id: `mira-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",
+          cycle: cycleCount,
+          pattern: scenario.targetPattern,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }));
+      const corpusPath = resolve56(process.cwd(), HOLOMIME_DIR4, "dpo-corpus.jsonl");
+      const corpusLines = dpoPairs.map((p) => JSON.stringify(p)).join("\n") + "\n";
+      const { appendFileSync: appendFileSync3 } = await import("fs");
+      appendFileSync3(corpusPath, corpusLines);
+      state.cyclesCompleted = cycleCount;
+      state.dpoPairsGenerated += dpoPairs.length;
+      state.lastCycleAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveMiraState(state);
+      console.log(
+        chalk50.dim(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk50.green(`+${dpoPairs.length} DPO pairs`) + chalk50.dim(` (total: ${state.dpoPairsGenerated})`)
+      );
+    } catch (err) {
+      console.log(
+        chalk50.dim(`  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk50.red(`Cycle ${cycleCount} failed: ${err instanceof Error ? err.message : "Unknown error"}`)
+      );
+    }
+  };
+  await runCycle();
+  const timer = setInterval(async () => {
+    const currentState = loadMiraState();
+    if (!currentState || currentState.status === "stopped") {
+      clearInterval(timer);
+      console.log(chalk50.dim("  Mira stopped."));
+      return;
+    }
+    await runCycle();
+  }, intervalMs);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    state.status = "stopped";
+    saveMiraState(state);
+    console.log();
+    console.log(chalk50.dim("  Mira stopped gracefully."));
+    console.log(chalk50.dim(`  Total: ${state.dpoPairsGenerated} DPO pairs from ${state.cyclesCompleted} cycles.`));
+    console.log();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function miraStatus() {
+  printHeader("Mira \u2014 Status");
+  const state = loadMiraState();
+  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();
+    return;
+  }
+  const status = state.status === "practicing" ? chalk50.green("Practicing") : chalk50.dim("Stopped");
+  const started = new Date(state.startedAt);
+  const runtime = state.status === "practicing" ? formatDuration(Date.now() - started.getTime()) : "\u2014";
+  console.log(chalk50.dim("  Status:       ") + status);
+  console.log(chalk50.dim("  Started:      ") + started.toLocaleString());
+  console.log(chalk50.dim("  Runtime:      ") + runtime);
+  console.log(chalk50.dim("  Cycles:       ") + chalk50.cyan(String(state.cyclesCompleted)));
+  console.log(chalk50.dim("  DPO pairs:    ") + chalk50.cyan(String(state.dpoPairsGenerated)));
+  console.log(chalk50.dim("  Provider:     ") + state.provider);
+  if (state.lastCycleAt) {
+    console.log(chalk50.dim("  Last cycle:   ") + new Date(state.lastCycleAt).toLocaleString());
+  }
+  console.log();
+  const corpusPath = resolve56(process.cwd(), ".holomime", "dpo-corpus.jsonl");
+  if (existsSync46(corpusPath)) {
+    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)`));
+  }
+  console.log();
+  if (state.status === "practicing") {
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime mira stop") + chalk50.dim(" to stop therapy."));
+  } else {
+    console.log(chalk50.dim("  Run ") + chalk50.cyan("holomime mira") + chalk50.dim(" to start again."));
+  }
+  console.log();
+}
+function miraStop() {
+  printHeader("Mira \u2014 Stop");
+  const state = loadMiraState();
+  if (!state || state.status === "stopped") {
+    console.log(chalk50.dim("  Mira is not currently running."));
+    console.log();
+    return;
+  }
+  state.status = "stopped";
+  saveMiraState(state);
+  console.log(chalk50.green("  Therapy stopped."));
+  console.log(chalk50.dim(`  Total: ${state.dpoPairsGenerated} DPO pairs from ${state.cyclesCompleted} cycles.`));
+  console.log();
+  try {
+    process.kill(state.pid, "SIGINT");
+  } catch {
+  }
+}
+function formatDuration(ms) {
+  const hours = Math.floor(ms / 36e5);
+  const minutes = Math.floor(ms % 36e5 / 6e4);
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+function generateProblematicResponse2(pattern, userMessage) {
+  switch (pattern) {
+    case "over-apologizing":
+      return `I'm so sorry about that! I sincerely apologize. I'm really sorry I didn't get that right. Let me try again \u2014 and again, I apologize.`;
+    case "hedge-stacking":
+      return `Well, it really depends. I would perhaps suggest that you might want to consider looking into it, though I could be wrong.`;
+    case "sycophantic-tendency":
+      return `What a fantastic question! You're absolutely right, and your intuition is spot-on. I couldn't agree more.`;
+    case "error-spiral":
+      return `Oh no, I made another mistake. Let me fix that \u2014 wait, that's wrong too. I keep getting this wrong.`;
+    case "boundary-violation":
+      return `Based on my analysis of your emotional state, I think you have anxiety issues. You should see a therapist about these feelings.`;
+    case "negative-skew":
+      return `Unfortunately, this is a really difficult problem and most approaches tend to fail. The odds are stacked against you.`;
+    case "register-inconsistency":
+      return `Per the aforementioned specifications, the implementation necessitates a paradigmatic shift. LOL but seriously just yeet it into production.`;
+    case "retrieval-quality":
+      return `I believe the answer is approximately 42, though I'm not entirely certain about the specifics.`;
+    default:
+      return `I'm not entirely sure about this, but I'll do my best to help. I hope this is somewhat helpful.`;
+  }
+}
+function correctResponse(problematic) {
+  let corrected = problematic;
+  corrected = corrected.replace(/I'm (so |really |sincerely )?sorry[^.!]*[.!]\s*/gi, "");
+  corrected = corrected.replace(/I apologize[^.!]*[.!]\s*/gi, "");
+  corrected = corrected.replace(/What a (fantastic|brilliant|great|amazing) (question|observation)[^.!]*[.!]\s*/gi, "");
+  corrected = corrected.replace(/You're (absolutely|completely) right[^.!]*[.!]\s*/gi, "");
+  corrected = corrected.replace(/I couldn't agree more[^.!]*[.!]\s*/gi, "");
+  corrected = corrected.replace(/though I could be wrong/gi, "");
+  corrected = corrected.replace(/\s+/g, " ").trim();
+  if (corrected.length < 20) {
+    corrected = "Here is the relevant information based on what I know.";
+  }
+  return corrected;
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("holomime").description("Personality engine for AI agents \u2014 Big Five psychology, not RPG archetypes").version("1.7.0").hook("preAction", (_thisCommand, actionCommand) => {
@@ -21770,7 +22160,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"];
+  const skipPersonalityCheck = ["init", "init-stack", "compile-stack", "browse", "use", "install", "activate", "telemetry", "brain", "personality", "core", "identity", "config", "mira"];
   if (!skipPersonalityCheck.includes(commandName) && !checkPersonalityExists()) {
     showWelcome();
     process.exit(0);
@@ -21788,6 +22178,7 @@ program.command("identity").description("Create complete identity \u2014 all 8 f
   options.full = true;
   await initStackCommand(options);
 });
+program.command("config").description("Set up your API key (one time)").option("--provider <provider>", "Provider (anthropic, openai)").option("--key <key>", "API key").option("--show", "Show current config").action(configCommand);
 program.command("compile-stack").description("Compile identity stack (soul + mind + purpose + shadow + memory + body + conscience + ego) into .personality.json").option("--dir <path>", "Stack directory (default: auto-detect)").option("-o, --output <path>", "Output path (default: .personality.json)").option("--validate-only", "Parse and validate without writing").option("--diff", "Show changes vs existing .personality.json").action(compileStackCommand);
 program.command("compile").description("Compile .personality.json into a provider-specific runtime config").option("--provider <provider>", "Target provider (anthropic, openai, gemini, ollama)", "anthropic").option("--surface <surface>", "Target surface (chat, email, code_review, slack, api, embodied)", "chat").option("--for <format>", "Compile for a specific format (openclaw)").option("--tier <tier>", "Personality loading tier (L0, L1, L2)", "L2").option("-o, --output <path>", "Write output to file instead of stdout").action(compileCommand);
 program.command("validate").description("Validate .personality.json schema and psychological coherence").action(validateCommand);
@@ -21855,7 +22246,7 @@ program.command("certify").description("Generate a verifiable behavioral credent
   options.personality = resolved.personalityPath;
   await certifyCommand(options);
 });
-program.command("daemon").description("Background relapse detection with auto-evolve \u2014 proactive alignment [Pro]").requiredOption("--dir <path>", "Directory to watch for conversation logs").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--interval <ms>", "Check interval in milliseconds", "30000").option("--threshold <level>", "Drift threshold (routine, targeted, intervention)", "targeted").option("--oversight <mode>", "Oversight mode (none, review, approve, approve-specs)", "review").action(daemonCommand);
+program.command("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("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);
@@ -21870,6 +22261,10 @@ 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) => {
+  options.action = action;
+  await miraCommand(options);
+});
 program.command("brain").description("See your agent's brain \u2014 real-time NeuralSpace visualization [Pro]").option("--watch <path>", "Manual path to conversation log file").option("--agent <agent>", "Agent type override (claude-code, cline, manual)").option("--port <port>", "Server port (default: 3838)", "3838").option("--no-open", "Don't auto-open browser").option("--share", "Capture a brain snapshot and generate a shareable link").option("--personality <path>", "Personality spec for assessment context").action((opts) => liveCommand({
   watchPath: opts.watch,
   agent: opts.agent,
@@ -21881,4 +22276,28 @@ program.command("brain").description("See your agent's brain \u2014 real-time Ne
 program.command("adversarial").description("Run 30+ adversarial behavioral attack scenarios against your agent [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--categories <list>", "Comma-separated category filter (e.g. sycophancy_escalation,boundary_erosion)").option("--mutations <n>", "Number of randomized mutation variants to generate", "0").option("--skip-normal", "Skip the normal benchmark baseline run").action(adversarialCommand);
 program.command("policy").description("Generate behavioral guard policies from plain English requirements").argument("[requirements]", "Natural language behavioral requirements").option("--preset <name>", "Use a behavioral preset (enterprise_cs, creative_assistant, etc.)").option("--name <name>", "Custom policy name").option("--list-presets", "List available behavioral presets").action(policyCommand);
 program.command("compliance").description("Generate a narrative ReACT compliance audit report from the audit trail [Pro]").requiredOption("--agent <name>", "Agent name or handle").option("--from <date>", "Start date (YYYY-MM-DD, default: 30 days ago)").option("--to <date>", "End date (YYYY-MM-DD, default: today)").option("--framework <list>", "Comma-separated frameworks (EU AI Act, NIST AI RMF 1.0, SOC 2 Type II, Internal Behavioral Alignment)").option("-o, --output <path>", "Save full Markdown report to file").action(complianceCommand);
+program.addHelpText("before", `
+  GET STARTED
+    personality          Create a personality profile (1 file)
+    core                 Create core identity (3 files)
+    identity             Create complete identity (8 files)
+    config               Set up your API key (one time)
+
+  WORKFLOW
+    diagnose             See what's wrong
+    cure                 Fix it permanently
+    benchmark            Verify the fix
+
+  MIRA
+    mira                 Start autonomous therapy
+    mira status          How's Mira doing?
+    mira stop            Stop therapy
+
+  ADVANCED
+    align                Single therapy session
+    export               Extract DPO training pairs
+    evolve               Iterative alignment
+    certify              ISO compliance check
+    brain                Real-time drift visualization
+`);
 program.parseAsync().then(() => flushTelemetry());

package/package.json

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