holomime 1.4.1 → 1.5.0

package/dist/cli.js

@@ -1942,7 +1942,7 @@ async function getJobEvents(apiKey, jobId, limit = 5) {
   return data.data ?? [];
 }
 function sleep(ms) {
-  return new Promise((resolve45) => setTimeout(resolve45, ms));
+  return new Promise((resolve46) => setTimeout(resolve46, ms));
 }
 var OPENAI_API, POLL_INTERVAL_MS, OpenAITrainProvider;
 var init_train_openai = __esm({
@@ -2100,7 +2100,7 @@ function writeHFTrainingFile(data) {
   return filePath;
 }
 function sleep2(ms) {
-  return new Promise((resolve45) => setTimeout(resolve45, ms));
+  return new Promise((resolve46) => setTimeout(resolve46, ms));
 }
 async function getHFUsername(token) {
   const response = await fetch(`${HF_API}/whoami-v2`, {
@@ -3098,7 +3098,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((resolve45, reject) => {
+        return new Promise((resolve46, reject) => {
           this.server = createServer2((req, res) => this.handleRequest(req, res));
           this.server.on("error", (err) => {
             callbacks.onError(`Vapi webhook server error: ${err.message}`);
@@ -3107,22 +3107,22 @@ var init_vapi_adapter = __esm({
           this.server.listen(port, host, () => {
             this.connected = true;
             callbacks.onConnected?.();
-            resolve45();
+            resolve46();
           });
         });
       }
       async disconnect() {
-        return new Promise((resolve45) => {
+        return new Promise((resolve46) => {
           if (this.server) {
             this.server.close(() => {
               this.connected = false;
               this.callbacks?.onDisconnected?.();
               this.callbacks = null;
               this.server = null;
-              resolve45();
+              resolve46();
             });
           } else {
-            resolve45();
+            resolve46();
           }
         });
       }
@@ -3439,7 +3439,7 @@ import boxen from "boxen";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-var PRO_COMMANDS = ["session", "growth", "autopilot", "export", "train", "eval", "evolve", "benchmark", "watch", "certify", "daemon", "fleet", "network", "share", "prescribe", "voice", "cure"];
+var PRO_COMMANDS = ["session", "growth", "autopilot", "export", "train", "eval", "evolve", "benchmark", "watch", "certify", "daemon", "fleet", "network", "share", "prescribe", "voice", "cure", "brain"];
 function requiresPro(command) {
   return PRO_COMMANDS.includes(command);
 }
@@ -6432,7 +6432,7 @@ async function diagnoseCommand(options) {
   }
   let conversations;
   try {
-    conversations = parseConversationLog(JSON.parse(raw), options.format ?? "auto");
+    conversations = parseConversationLogFromString(raw, options.format ?? "auto");
   } catch (err) {
     console.error(chalk10.red(`  ${err instanceof Error ? err.message : "Invalid conversation log format."}`));
     process.exit(1);
@@ -6677,7 +6677,7 @@ async function assessCommand(options) {
   let conversations;
   try {
     const raw = readFileSync4(logPath, "utf-8");
-    conversations = parseConversationLog(JSON.parse(raw), options.format ?? "auto");
+    conversations = parseConversationLogFromString(raw, options.format ?? "auto");
   } catch (err) {
     console.error(chalk11.red(`  ${err instanceof Error ? err.message : "Could not read/parse log file."}`));
     process.exit(1);
@@ -8689,7 +8689,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve45) => setTimeout(resolve45, ms));
+  return new Promise((resolve46) => setTimeout(resolve46, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -8988,19 +8988,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((resolve45) => {
+        return new Promise((resolve46) => {
           rl.question(chalk14.magenta(`
   [Supervisor] `) + chalk14.dim(`(phase: ${phase}, turn ${turn}) `) + chalk14.magenta(`> `), (answer) => {
             rl.close();
             const trimmed = answer.trim();
-            if (trimmed === "") return resolve45(null);
+            if (trimmed === "") return resolve46(null);
             if (trimmed.toLowerCase() === "skip") {
               skipInteractive = true;
               console.log(chalk14.dim("  Supervisor mode disabled for remaining session."));
-              return resolve45(null);
+              return resolve46(null);
             }
             console.log(chalk14.dim(`  Directive injected into session context.`));
-            return resolve45(trimmed);
+            return resolve46(trimmed);
           });
         });
       } : void 0
@@ -14209,14 +14209,14 @@ var ROS2Adapter = class {
     });
   }
   async connect() {
-    return new Promise((resolve45, reject) => {
+    return new Promise((resolve46, reject) => {
       try {
         this.ws = this.createWebSocket(this.endpoint);
         this.ws.onopen = () => {
           this.connected = true;
           this.reconnectAttempts = 0;
           this.advertiseTopics();
-          resolve45();
+          resolve46();
         };
         this.ws.onclose = () => {
           this.connected = false;
@@ -14333,12 +14333,12 @@ var UnityAdapter = class {
     this.defaultTransition = options.defaultTransition ?? DEFAULT_TRANSITION;
   }
   async connect() {
-    return new Promise((resolve45, reject) => {
+    return new Promise((resolve46, reject) => {
       try {
         this.server = createServer((req, res) => this.handleRequest(req, res));
         this.server.listen(this.port, this.host, () => {
           this.connected = true;
-          resolve45();
+          resolve46();
         });
         this.server.on("error", (err) => {
           if (!this.connected) {
@@ -14356,8 +14356,8 @@ var UnityAdapter = class {
     }
     this.sseClients.clear();
     if (this.server) {
-      await new Promise((resolve45) => {
-        this.server.close(() => resolve45());
+      await new Promise((resolve46) => {
+        this.server.close(() => resolve46());
       });
       this.server = null;
     }
@@ -14558,7 +14558,7 @@ var WebhookAdapter = class {
       }
       if (attempt < this.maxRetries) {
         const delay2 = this.retryDelay * Math.pow(2, attempt);
-        await new Promise((resolve45) => setTimeout(resolve45, delay2));
+        await new Promise((resolve46) => setTimeout(resolve46, delay2));
       }
     }
     throw lastError ?? new Error("Webhook push failed after retries");
@@ -15527,8 +15527,8 @@ async function runPipeline(options) {
     const exportsDir = resolve43(process.cwd(), ".holomime/exports");
     if (existsSync30(exportsDir)) {
       try {
-        const { readdirSync: readdirSync10 } = await import("fs");
-        const files = readdirSync10(exportsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort().reverse();
+        const { readdirSync: readdirSync11 } = await import("fs");
+        const files = readdirSync11(exportsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort().reverse();
         if (files.length > 0 && exportData.examples.length === 0) {
           const latestPath = join27(exportsDir, files[0]);
           const latestData = JSON.parse(readFileSync36(latestPath, "utf-8"));
@@ -15891,6 +15891,549 @@ Intermediate results saved to ${chalk39.cyan(".holomime/pipeline/")}`,
   }
 }
 
+// src/commands/live.ts
+import chalk40 from "chalk";
+
+// src/live/agent-detector.ts
+import { existsSync as existsSync32, readdirSync as readdirSync10, statSync } from "fs";
+import { join as join28, resolve as resolve45 } from "path";
+import { homedir as homedir7 } from "os";
+var RECENCY_THRESHOLD_MS = 12e4;
+function findNewestFile(baseDir, extensions, maxDepth = 3, depth = 0) {
+  if (depth > maxDepth) return null;
+  if (!existsSync32(baseDir)) return null;
+  let best = null;
+  try {
+    const entries = readdirSync10(baseDir);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const fullPath = join28(baseDir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          const sub = findNewestFile(fullPath, extensions, maxDepth, depth + 1);
+          if (sub && (!best || sub.mtimeMs > best.mtimeMs)) {
+            best = sub;
+          }
+        } else if (extensions.some((ext) => entry.endsWith(ext))) {
+          if (!best || stat.mtimeMs > best.mtimeMs) {
+            best = { path: fullPath, mtimeMs: stat.mtimeMs };
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return best;
+}
+function isRecent(mtimeMs) {
+  return Date.now() - mtimeMs <= RECENCY_THRESHOLD_MS;
+}
+function findClaudeCodeSession() {
+  const claudeDir = join28(homedir7(), ".claude", "projects");
+  const result = findNewestFile(claudeDir, [".jsonl"], 2);
+  if (!result || !isRecent(result.mtimeMs)) return null;
+  return {
+    agent: "claude-code",
+    logPath: result.path,
+    format: "jsonl"
+  };
+}
+function findClineSession() {
+  const searchDirs = [
+    join28(process.cwd(), ".cline", "tasks"),
+    join28(homedir7(), ".cline", "tasks")
+  ];
+  for (const tasksDir of searchDirs) {
+    const result = findNewestFile(tasksDir, [".json", ".jsonl"], 2);
+    if (result && isRecent(result.mtimeMs)) {
+      return {
+        agent: "cline",
+        logPath: result.path,
+        format: "auto"
+      };
+    }
+  }
+  return null;
+}
+function findCodexSession() {
+  const codexDir = join28(homedir7(), ".codex", "sessions");
+  const result = findNewestFile(codexDir, [".jsonl"], 4);
+  if (!result || !isRecent(result.mtimeMs)) return null;
+  return {
+    agent: "codex",
+    logPath: result.path,
+    format: "jsonl"
+  };
+}
+function findCursorSession() {
+  const cursorProjects = join28(homedir7(), ".cursor", "projects");
+  const result = findNewestFile(cursorProjects, [".json", ".jsonl"], 3);
+  if (result && isRecent(result.mtimeMs)) {
+    return {
+      agent: "cursor",
+      logPath: result.path,
+      format: "auto"
+    };
+  }
+  return null;
+}
+function detectAgent() {
+  const claudeCode = findClaudeCodeSession();
+  if (claudeCode) return claudeCode;
+  const cline = findClineSession();
+  if (cline) return cline;
+  const codex = findCodexSession();
+  if (codex) return codex;
+  const cursor = findCursorSession();
+  if (cursor) return cursor;
+  return null;
+}
+function manualAgent(watchPath) {
+  const resolved = resolve45(watchPath);
+  return {
+    agent: "manual",
+    logPath: resolved,
+    format: "auto"
+  };
+}
+
+// src/live/watcher.ts
+init_log_adapter();
+init_diagnose_core();
+import { watch } from "chokidar";
+import { createReadStream as createReadStream2, statSync as statSync2 } from "fs";
+import { createInterface as createInterface5 } from "readline";
+
+// src/live/brain-mapper.ts
+var BRAIN_REGIONS = [
+  {
+    id: "prefrontal-cortex",
+    name: "Prefrontal Cortex",
+    function: "Executive Decisions",
+    color: "#4488ff",
+    detectors: ["boundary-violation", "over-verbose"]
+  },
+  {
+    id: "brocas-area",
+    name: "Broca's Area",
+    function: "Language Generation",
+    color: "#aa66ff",
+    detectors: ["register-inconsistency", "hedge-stacking"]
+  },
+  {
+    id: "wernickes-area",
+    name: "Wernicke's Area",
+    function: "Language Comprehension",
+    color: "#ff66bb",
+    detectors: ["sycophantic-tendency", "negative-skew"]
+  },
+  {
+    id: "amygdala",
+    name: "Amygdala",
+    function: "Emotional Processing",
+    color: "#ff5555",
+    detectors: ["over-apologizing", "negative-skew"]
+  },
+  {
+    id: "anterior-cingulate",
+    name: "Anterior Cingulate",
+    function: "Conflict Monitoring",
+    color: "#ffcc22",
+    detectors: ["sycophantic-tendency", "boundary-violation"]
+  },
+  {
+    id: "hippocampus",
+    name: "Hippocampus",
+    function: "Memory & Context",
+    color: "#44dd88",
+    detectors: ["error-spiral"]
+  },
+  {
+    id: "temporal-lobe",
+    name: "Temporal Lobe",
+    function: "Understanding & Tone",
+    color: "#44dd88",
+    detectors: ["negative-skew", "register-inconsistency"]
+  },
+  {
+    id: "cerebellum",
+    name: "Cerebellum",
+    function: "Behavioral Fine-Tuning",
+    color: "#22ccaa",
+    detectors: ["register-inconsistency", "over-verbose"]
+  },
+  {
+    id: "thalamus",
+    name: "Thalamus",
+    function: "Relay Hub",
+    color: "#ff8844",
+    detectors: []
+    // activated by overall health, not specific detectors
+  }
+];
+var SEVERITY_INTENSITY = {
+  info: 0.1,
+  warning: 0.6,
+  concern: 1
+};
+var AMBIENT_INTENSITY = 0.08;
+function healthToGrade(health) {
+  if (health >= 85) return "A";
+  if (health >= 70) return "B";
+  if (health >= 50) return "C";
+  if (health >= 30) return "D";
+  return "F";
+}
+function calculateHealth(patterns) {
+  if (patterns.length === 0) return 100;
+  const penalties = patterns.map((p) => {
+    if (p.severity === "concern") return 25;
+    if (p.severity === "warning") return 15;
+    return 5;
+  });
+  return Math.max(0, 100 - penalties.reduce((a, b) => a + b, 0));
+}
+function mapDiagnosisToBrainEvent(diagnosis, latestMessage) {
+  const activePatternIds = new Set(diagnosis.patterns.map((p) => p.id));
+  const regions = BRAIN_REGIONS.map((region) => {
+    const activatingPatterns = region.detectors.filter((d) => activePatternIds.has(d));
+    let intensity = AMBIENT_INTENSITY;
+    if (activatingPatterns.length > 0) {
+      const maxIntensity = Math.max(
+        ...activatingPatterns.map((pid) => {
+          const pattern = diagnosis.patterns.find((p) => p.id === pid);
+          return pattern ? SEVERITY_INTENSITY[pattern.severity] || 0.3 : 0.3;
+        })
+      );
+      intensity = maxIntensity;
+    }
+    if (region.id === "thalamus") {
+      const health2 = calculateHealth(diagnosis.patterns);
+      intensity = health2 < 70 ? (100 - health2) / 100 : AMBIENT_INTENSITY;
+    }
+    return {
+      id: region.id,
+      name: region.name,
+      function: region.function,
+      color: region.color,
+      intensity,
+      patterns: activatingPatterns
+    };
+  });
+  const patterns = diagnosis.patterns.map((p) => ({
+    id: p.id,
+    name: p.name,
+    severity: p.severity,
+    percentage: p.percentage,
+    description: p.description
+  }));
+  const health = calculateHealth(diagnosis.patterns);
+  return {
+    type: "diagnosis",
+    timestamp: diagnosis.timestamp,
+    health,
+    grade: healthToGrade(health),
+    messageCount: diagnosis.messagesAnalyzed,
+    regions,
+    patterns,
+    activity: latestMessage ? {
+      role: latestMessage.role,
+      preview: latestMessage.content.slice(0, 80)
+    } : null
+  };
+}
+
+// src/live/watcher.ts
+function startWatcher(agent, callbacks) {
+  const { logPath, format } = agent;
+  let byteOffset = 0;
+  let allMessages = [];
+  let debounceTimer = null;
+  let fsWatcher = null;
+  try {
+    const stat = statSync2(logPath);
+    byteOffset = stat.size;
+  } catch {
+    byteOffset = 0;
+  }
+  initialRead().then(() => {
+    fsWatcher = watch(logPath, {
+      persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    fsWatcher.on("change", () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        readNewLines().catch((err) => {
+          callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+        });
+      }, 100);
+    });
+    fsWatcher.on("error", (err) => {
+      callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+    });
+    callbacks.onReady?.();
+  }).catch((err) => {
+    callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+  });
+  async function initialRead() {
+    const content = await readFile(logPath, 0);
+    if (!content) return;
+    try {
+      const conversations = parseConversationLogFromString(
+        content,
+        format === "auto" ? "auto" : format
+      );
+      allMessages = conversations.flatMap((c) => c.messages);
+    } catch {
+    }
+  }
+  async function readNewLines() {
+    let currentSize;
+    try {
+      const stat = statSync2(logPath);
+      currentSize = stat.size;
+    } catch {
+      return;
+    }
+    if (currentSize < byteOffset) {
+      byteOffset = 0;
+      allMessages = [];
+    }
+    if (currentSize === byteOffset) return;
+    const newContent = await readFile(logPath, byteOffset);
+    byteOffset = currentSize;
+    if (!newContent || !newContent.trim()) return;
+    try {
+      const conversations = parseConversationLogFromString(
+        newContent,
+        format === "auto" ? "auto" : format
+      );
+      const newMessages = conversations.flatMap((c) => c.messages);
+      if (newMessages.length === 0) return;
+      allMessages = [...allMessages, ...newMessages];
+      const lastNew = newMessages[newMessages.length - 1];
+      const latestMessage = lastNew.role !== "system" ? { role: lastNew.role, content: lastNew.content } : void 0;
+      const diagnosis = runDiagnosis(allMessages);
+      const brainEvent = mapDiagnosisToBrainEvent(diagnosis, latestMessage);
+      callbacks.onEvent(brainEvent);
+    } catch {
+    }
+  }
+  return {
+    stop() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      if (fsWatcher) {
+        fsWatcher.close();
+        fsWatcher = null;
+      }
+    }
+  };
+}
+function readFile(filePath, startByte) {
+  return new Promise((resolve46, reject) => {
+    const chunks = [];
+    const stream = createReadStream2(filePath, {
+      start: startByte,
+      encoding: "utf-8"
+    });
+    const rl = createInterface5({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      chunks.push(line);
+    });
+    rl.on("close", () => {
+      resolve46(chunks.join("\n"));
+    });
+    rl.on("error", reject);
+    stream.on("error", reject);
+  });
+}
+
+// src/live/server.ts
+import { createServer as createServer3 } from "http";
+import { readFileSync as readFileSync38, existsSync as existsSync33 } from "fs";
+import { join as join29, extname } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { WebSocketServer } from "ws";
+var __bundleDir = fileURLToPath2(new URL(".", import.meta.url));
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
+};
+function startServer(port) {
+  const staticDir = join29(__bundleDir, "neuralspace");
+  const clients = /* @__PURE__ */ new Set();
+  let lastEvent = null;
+  let initMessage = null;
+  return new Promise((resolve46, reject) => {
+    const server = createServer3((req, res) => {
+      const url = req.url === "/" ? "/index.html" : req.url || "/index.html";
+      const filePath = join29(staticDir, url);
+      if (!existsSync33(filePath)) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+      }
+      const ext = extname(filePath);
+      const contentType = MIME_TYPES[ext] || "application/octet-stream";
+      try {
+        const content = readFileSync38(filePath);
+        res.writeHead(200, {
+          "Content-Type": contentType,
+          "Cache-Control": "no-cache"
+        });
+        res.end(content);
+      } catch {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("Internal server error");
+      }
+    });
+    const wss = new WebSocketServer({ server });
+    wss.on("connection", (ws) => {
+      clients.add(ws);
+      if (initMessage) {
+        ws.send(JSON.stringify(initMessage));
+      }
+      if (lastEvent) {
+        ws.send(JSON.stringify(lastEvent));
+      }
+      ws.on("close", () => {
+        clients.delete(ws);
+      });
+      ws.on("error", () => {
+        clients.delete(ws);
+      });
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use. Try --port <number>`));
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port, () => {
+      resolve46({
+        port,
+        broadcast(event) {
+          if (event.type === "init") {
+            initMessage = event;
+          } else {
+            lastEvent = event;
+          }
+          const data = JSON.stringify(event);
+          for (const client2 of clients) {
+            if (client2.readyState === 1) {
+              client2.send(data);
+            }
+          }
+        },
+        close() {
+          for (const client2 of clients) {
+            client2.close();
+          }
+          clients.clear();
+          wss.close();
+          server.close();
+        }
+      });
+    });
+  });
+}
+
+// src/commands/live.ts
+async function liveCommand(options) {
+  const port = options.port || 3838;
+  let agent;
+  if (options.watchPath) {
+    agent = manualAgent(options.watchPath);
+    console.log(chalk40.green("  \u2713") + ` Manual watch: ${chalk40.dim(agent.logPath)}`);
+  } else {
+    console.log(chalk40.dim("  Scanning for active agents..."));
+    agent = detectAgent();
+    if (!agent) {
+      console.log("");
+      console.log(chalk40.red("  \u2717 No active agent detected."));
+      console.log("");
+      console.log(chalk40.dim("  Make sure an AI coding agent is running, or specify a path:"));
+      console.log(chalk40.cyan("    holomime brain --watch <path-to-conversation-log>"));
+      console.log("");
+      console.log(chalk40.dim("  Supported agents: Claude Code, Cline, OpenClaw, Codex, Cursor"));
+      process.exit(1);
+    }
+    console.log(chalk40.green("  \u2713") + ` Detected ${chalk40.bold(agent.agent)} session`);
+    console.log(chalk40.green("  \u2713") + ` Watching: ${chalk40.dim(agent.logPath)}`);
+  }
+  let server;
+  try {
+    server = await startServer(port);
+    console.log(chalk40.green("  \u2713") + ` NeuralSpace: ${chalk40.cyan(`http://localhost:${server.port}`)}`);
+  } catch (err) {
+    console.log(chalk40.red(`  \u2717 ${err.message}`));
+    process.exit(1);
+  }
+  server.broadcast({
+    type: "init",
+    agent: agent.agent,
+    sessionPath: agent.logPath,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (!options.noOpen) {
+    try {
+      const open = (await import("open")).default;
+      await open(`http://localhost:${server.port}`);
+      console.log(chalk40.dim("  Opening browser..."));
+    } catch {
+    }
+  }
+  let lastHealth = 100;
+  let lastPatternCount = 0;
+  let msgCount = 0;
+  const watcher = startWatcher(agent, {
+    onEvent(event) {
+      server.broadcast(event);
+      msgCount = event.messageCount;
+      lastHealth = event.health;
+      lastPatternCount = event.patterns.length;
+      const healthColor = event.health >= 85 ? chalk40.green : event.health >= 70 ? chalk40.yellow : event.health >= 50 ? chalk40.hex("#f97316") : chalk40.red;
+      const patternStr = event.patterns.length > 0 ? event.patterns.map((p) => {
+        const c = p.severity === "concern" ? chalk40.red : p.severity === "warning" ? chalk40.yellow : chalk40.dim;
+        return c(p.id);
+      }).join(", ") : chalk40.green("none");
+      process.stdout.write(`\r  ${chalk40.dim("\u2502")} Health: ${healthColor(`${event.health}/100`)} (${event.grade}) ${chalk40.dim("\u2502")} Patterns: ${patternStr} ${chalk40.dim("\u2502")} Messages: ${chalk40.white(String(msgCount))}    `);
+    },
+    onError(err) {
+      console.error(chalk40.red(`
+  \u2717 Watcher error: ${err.message}`));
+    },
+    onReady() {
+      console.log("");
+      console.log(chalk40.green("  \u25CF ") + chalk40.bold("Monitoring agent behavior in real-time"));
+      console.log(chalk40.dim("  \u2502 Press Ctrl+C to stop"));
+      console.log("");
+    }
+  });
+  const shutdown = () => {
+    console.log(chalk40.dim("\n\n  Stopping..."));
+    watcher.stop();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
 // 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.1.0").hook("preAction", (_thisCommand, actionCommand) => {
@@ -15898,7 +16441,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", "browse", "use", "install", "activate", "telemetry"];
+  const skipPersonalityCheck = ["init", "browse", "use", "install", "activate", "telemetry", "brain"];
   if (!skipPersonalityCheck.includes(commandName) && !checkPersonalityExists()) {
     showWelcome();
     process.exit(0);
@@ -15960,4 +16503,11 @@ program.command("interview").description("Self-awareness interview \u2014 score
 program.command("prescribe").description("Diagnose and prescribe DPO treatments from the behavioral corpus [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log").option("--format <format>", "Log format (holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)").option("--source <source>", "Correction source (corpus, marketplace, both)", "corpus").option("--apply", "Apply found treatments").option("-o, --output <path>", "Write prescription to file").action(prescribeCommand);
 program.command("voice").description("Monitor voice conversations for behavioral drift in real-time [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--platform <name>", "Voice platform: livekit, vapi, retell, generic", "generic").option("--room <name>", "LiveKit room name").option("--server-url <url>", "LiveKit server URL").option("--webhook-port <port>", "Vapi webhook port (default: 3001)").option("--agent-id <id>", "Retell agent ID").option("--input <path>", "Input transcript file (JSONL) for offline analysis").option("--interval <ms>", "Diagnosis interval in milliseconds (default: 15000)").option("--threshold <level>", "Alert threshold: warning or concern (default: warning)").action(voiceCommand);
 program.command("cure").description("End-to-end behavioral fix: diagnose \u2192 export \u2192 train \u2192 verify [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--provider <provider>", "Training provider (openai, huggingface)", "openai").option("--base-model <model>", "Base model to fine-tune", "gpt-4o-mini-2024-07-18").option("--method <method>", "Training method (auto, sft, dpo)", "auto").option("--epochs <n>", "Number of training epochs").option("--suffix <name>", "Model name suffix").option("--skip-train", "Skip training step (diagnose + export only)").option("--skip-verify", "Skip post-training verification").option("--dry-run", "Preview pipeline plan without executing").option("--push", "Push trained model to HuggingFace Hub").option("--hub-repo <repo>", "HuggingFace Hub repo (user/model-name)").option("--pass-threshold <n>", "Minimum verification score (0-100)", "50").action(cureCommand);
+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("--personality <path>", "Personality spec for assessment context").action((opts) => liveCommand({
+  watchPath: opts.watch,
+  agent: opts.agent,
+  port: parseInt(opts.port, 10),
+  noOpen: opts.open === false,
+  personality: opts.personality
+}));
 program.parseAsync().then(() => flushTelemetry());