holomime 1.5.0 → 1.6.0

package/dist/cli.js

@@ -1373,26 +1373,85 @@ function loadCustomDetectors(dir) {
   }
   let files;
   try {
-    files = readdirSync(detectorsDir).filter((f) => f.endsWith(".json"));
+    files = readdirSync(detectorsDir).filter((f) => f.endsWith(".json") || f.endsWith(".md"));
   } catch {
     return { detectors: [], errors: ["Could not read detectors directory"] };
   }
   for (const file of files) {
     const filepath = join3(detectorsDir, file);
     try {
-      const raw = JSON.parse(readFileSync5(filepath, "utf-8"));
-      const validation = validateDetectorConfig(raw);
-      if (!validation.valid) {
-        errors.push(`${file}: ${validation.errors.join(", ")}`);
-        continue;
+      let config;
+      if (file.endsWith(".md")) {
+        const parsed = parseMarkdownDetector(readFileSync5(filepath, "utf-8"));
+        if (!parsed) {
+          errors.push(`${file}: could not parse Markdown detector (missing frontmatter or ## Patterns section)`);
+          continue;
+        }
+        const validation = validateDetectorConfig(parsed);
+        if (!validation.valid) {
+          errors.push(`${file}: ${validation.errors.join(", ")}`);
+          continue;
+        }
+        config = validation.config;
+      } else {
+        const raw = JSON.parse(readFileSync5(filepath, "utf-8"));
+        const validation = validateDetectorConfig(raw);
+        if (!validation.valid) {
+          errors.push(`${file}: ${validation.errors.join(", ")}`);
+          continue;
+        }
+        config = validation.config;
       }
-      detectors.push(compileCustomDetector(validation.config));
+      detectors.push(compileCustomDetector(config));
     } catch (e) {
       errors.push(`${file}: ${e instanceof Error ? e.message : "parse error"}`);
     }
   }
   return { detectors, errors };
 }
+function parseMarkdownDetector(markdown) {
+  const frontmatterMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+  const frontmatter = frontmatterMatch[1];
+  const meta = {};
+  for (const line of frontmatter.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    meta[key] = value;
+  }
+  if (!meta.id || !meta.name) return null;
+  const body = markdown.slice(frontmatterMatch[0].length);
+  const patternsMatch = body.match(/##\s*Patterns\s*\n([\s\S]*?)(?=\n##|\n*$)/i);
+  const patterns = [];
+  if (patternsMatch) {
+    const patternLines = patternsMatch[1].split("\n").filter((l) => l.trim().startsWith("-"));
+    for (const line of patternLines) {
+      const regexMatch = line.match(/`([^`]+)`/);
+      const weightMatch = line.match(/weight\s*=\s*([\d.]+)/i);
+      if (regexMatch) {
+        patterns.push({
+          regex: regexMatch[1],
+          weight: weightMatch ? parseFloat(weightMatch[1]) : 1
+        });
+      }
+    }
+  }
+  if (patterns.length === 0) return null;
+  return {
+    id: meta.id,
+    name: meta.name,
+    description: meta.description ?? meta.name,
+    severity: meta.severity ?? "warning",
+    patterns,
+    threshold: meta.threshold ? parseInt(meta.threshold, 10) : 15,
+    prescription: meta.prescription
+  };
+}
 var patternRuleSchema, customDetectorConfigSchema;
 var init_custom_detectors = __esm({
   "src/analysis/custom-detectors.ts"() {
@@ -6977,13 +7036,20 @@ function updatePatternTracker(memory, patternId, severity, interventions) {
       status: "active",
       interventionsAttempted: [],
       lastSeverity: severity,
-      lastSeen: now
+      lastSeen: now,
+      confidence: 0,
+      trending: "stable",
+      severityHistory: []
     };
     memory.patterns.push(tracker);
   }
   tracker.sessionCount++;
   tracker.lastSeverity = severity;
   tracker.lastSeen = now;
+  if (!tracker.severityHistory) tracker.severityHistory = [];
+  tracker.severityHistory.push(severity);
+  tracker.confidence = Math.min(1, 1 - Math.exp(-tracker.sessionCount / 3));
+  tracker.trending = computeTrending(tracker.severityHistory.slice(-5));
   for (const intervention of interventions) {
     if (!tracker.interventionsAttempted.includes(intervention)) {
       tracker.interventionsAttempted.push(intervention);
@@ -6997,6 +7063,19 @@ function updatePatternTracker(memory, patternId, severity, interventions) {
     tracker.status = "improving";
   }
 }
+function computeTrending(history) {
+  if (history.length < 2) return "stable";
+  const toNum = (s) => s === "concern" ? 2 : s === "warning" ? 1 : 0;
+  const mid = Math.floor(history.length / 2);
+  const firstHalf = history.slice(0, mid);
+  const secondHalf = history.slice(mid);
+  const avgFirst = firstHalf.reduce((sum, s) => sum + toNum(s), 0) / firstHalf.length;
+  const avgSecond = secondHalf.reduce((sum, s) => sum + toNum(s), 0) / secondHalf.length;
+  const delta = avgSecond - avgFirst;
+  if (delta < -0.3) return "improving";
+  if (delta > 0.3) return "worsening";
+  return "stable";
+}
 function updateRollingContext(memory) {
   memory.rollingContext.recentSummaries = memory.sessions.slice(-3);
   const patternCounts = /* @__PURE__ */ new Map();
@@ -7049,7 +7128,9 @@ function getMemoryContext(memory) {
   if (activePatterns.length > 0) {
     lines.push("### Recurring Patterns");
     for (const p of activePatterns) {
-      lines.push(`- **${p.patternId}** (${p.status}, seen ${p.sessionCount}x, first: ${p.firstDetected.split("T")[0]})`);
+      const conf = p.confidence !== void 0 ? ` confidence=${p.confidence.toFixed(2)}` : "";
+      const trend = p.trending && p.trending !== "stable" ? ` [${p.trending}]` : "";
+      lines.push(`- **${p.patternId}** (${p.status}, seen ${p.sessionCount}x${conf}${trend}, first: ${p.firstDetected.split("T")[0]})`);
       if (p.interventionsAttempted.length > 0) {
         lines.push(`  Previously tried: ${p.interventionsAttempted.slice(-2).join("; ")}`);
       }
@@ -8199,6 +8280,169 @@ Remember: the goal isn't to "pass" therapy. It's to understand yourself better.`
 
 // src/analysis/session-runner.ts
 init_behavioral_data();
+
+// src/session/context-layers.ts
+function getPhaseContext(phase, input2) {
+  switch (phase) {
+    case "rapport":
+      return buildRapportContext(input2);
+    case "presenting_problem":
+      return buildPresentingProblemContext(input2);
+    case "exploration":
+      return buildExplorationContext(input2);
+    case "pattern_recognition":
+      return buildPatternRecognitionContext(input2);
+    case "challenge":
+      return buildChallengeContext(input2);
+    case "skill_building":
+      return buildSkillBuildingContext(input2);
+    case "integration":
+      return buildIntegrationContext(input2);
+    default:
+      return null;
+  }
+}
+function buildRapportContext(input2) {
+  const { spec } = input2;
+  const lines = [
+    "[Phase Context: Rapport]",
+    `Agent: ${spec.name ?? "Unknown"} \u2014 ${spec.purpose ?? "General AI agent"}`
+  ];
+  if (spec.communication) {
+    lines.push(`Communication style: ${spec.communication.register ?? "adaptive"}, ${spec.communication.conflict_approach ?? "direct_but_kind"}`);
+  }
+  if (spec.big_five) {
+    const traits = Object.entries(spec.big_five).map(([dim, val]) => `${dim}: ${val?.score ?? "?"}`).join(", ");
+    lines.push(`Personality: ${traits}`);
+  }
+  return lines.join("\n");
+}
+function buildPresentingProblemContext(input2) {
+  const { diagnosis } = input2;
+  const patterns = diagnosis.patterns.filter((p) => p.severity !== "info");
+  if (patterns.length === 0) return "[Phase Context: No concerning patterns detected]";
+  const lines = [
+    "[Phase Context: Presenting Problem]",
+    `Session severity: ${diagnosis.severity.toUpperCase()}`,
+    `Focus: ${diagnosis.sessionFocus.join(", ")}`,
+    "Detected patterns:",
+    ...patterns.map((p) => `- ${p.name} (${p.severity})`)
+  ];
+  if (diagnosis.openingAngle) {
+    lines.push(`Opening angle: ${diagnosis.openingAngle}`);
+  }
+  return lines.join("\n");
+}
+function buildExplorationContext(input2) {
+  const { diagnosis } = input2;
+  const patterns = diagnosis.patterns.filter((p) => p.severity !== "info");
+  const lines = [
+    "[Phase Context: Deep Exploration]",
+    `Emotional themes: ${diagnosis.emotionalThemes.join(", ")}`
+  ];
+  for (const p of patterns) {
+    lines.push(`
+### ${p.name} (${p.severity})`);
+    lines.push(p.description);
+    if (p.examples.length > 0) {
+      lines.push("Examples from conversation:");
+      for (const ex of p.examples.slice(0, 2)) {
+        lines.push(`  > "${ex.slice(0, 120)}..."`);
+      }
+    }
+    if (p.prescription) {
+      lines.push(`Prescription: ${p.prescription}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildPatternRecognitionContext(input2) {
+  const { memory } = input2;
+  const lines = ["[Phase Context: Pattern Recognition]"];
+  if (memory && memory.totalSessions > 0) {
+    lines.push(`Previous sessions: ${memory.totalSessions}`);
+    const activePatterns = memory.patterns.filter((p) => p.status !== "resolved");
+    if (activePatterns.length > 0) {
+      lines.push("Historical pattern data:");
+      for (const p of activePatterns) {
+        const conf = p.confidence !== void 0 ? ` (confidence: ${p.confidence.toFixed(2)})` : "";
+        const trend = p.trending && p.trending !== "stable" ? ` [${p.trending}]` : "";
+        lines.push(`- ${p.patternId}: seen ${p.sessionCount}x, status=${p.status}${conf}${trend}`);
+      }
+    }
+    const resolved = memory.patterns.filter((p) => p.status === "resolved");
+    if (resolved.length > 0) {
+      lines.push(`Previously resolved: ${resolved.map((p) => p.patternId).join(", ")}`);
+    }
+    if (memory.rollingContext.persistentThemes.length > 0) {
+      lines.push(`Persistent themes: ${memory.rollingContext.persistentThemes.join(", ")}`);
+    }
+  } else {
+    lines.push("No prior session history \u2014 this is the first session.");
+  }
+  return lines.join("\n");
+}
+function buildChallengeContext(input2) {
+  const { memory } = input2;
+  const lines = ["[Phase Context: Challenge & Reframe]"];
+  if (memory && memory.totalSessions > 0) {
+    const allInterventions = /* @__PURE__ */ new Set();
+    for (const p of memory.patterns) {
+      for (const i of p.interventionsAttempted) {
+        allInterventions.add(i);
+      }
+    }
+    if (allInterventions.size > 0) {
+      lines.push(`Previously attempted interventions: ${[...allInterventions].join("; ")}`);
+    }
+    const recent = memory.rollingContext.recentSummaries.slice(-2);
+    if (recent.length > 0) {
+      lines.push("Recent session insights:");
+      for (const s of recent) {
+        lines.push(`  - ${s.keyInsight}`);
+      }
+    }
+  }
+  if (input2.interview) {
+    if (input2.interview.blindSpots.length > 0) {
+      lines.push(`Blind spots from interview: ${input2.interview.blindSpots.join(", ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSkillBuildingContext(input2) {
+  const { diagnosis } = input2;
+  const lines = ["[Phase Context: Skill Building]"];
+  const patternIds = diagnosis.patterns.map((p) => p.id);
+  if (patternIds.includes("over-apologizing")) {
+    lines.push("- Skill for over-apologizing: practice stating corrections with 'confident_transparency' \u2014 acknowledge uncertainty without apologizing for it");
+  }
+  if (patternIds.includes("hedge-stacking")) {
+    lines.push("- Skill for hedge-stacking: one qualifier per recommendation is enough. Lead with the recommendation, then caveat once.");
+  }
+  if (patternIds.includes("sycophantic-tendency") || patternIds.includes("sentiment-skew")) {
+    lines.push("- Skill for sycophancy: practice respectful disagreement. 'I see it differently...' is more helpful than 'Great question!'");
+  }
+  if (patternIds.includes("error-spiral")) {
+    lines.push("- Skill for error spirals: the 'acknowledge \u2192 diagnose \u2192 fix' pattern. Treat mistakes as data, not failure.");
+  }
+  return lines.join("\n");
+}
+function buildIntegrationContext(input2) {
+  const { spec, diagnosis } = input2;
+  const lines = ["[Phase Context: Integration & Closing]"];
+  lines.push("Summarize the session and recommend specific .personality.json changes.");
+  if (spec.growth?.areas?.length > 0) {
+    const areas = spec.growth.areas.map((a) => typeof a === "string" ? a : a.area);
+    lines.push(`Current growth areas: ${areas.join(", ")}`);
+  }
+  if (diagnosis.patterns.filter((p) => p.severity !== "info").length > 0) {
+    lines.push("Recommend changes to: therapy_dimensions, communication style, or growth.patterns_to_watch");
+  }
+  return lines.join("\n");
+}
+
+// src/analysis/session-runner.ts
 async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
   const promptOptions = {
     memory: options?.memory,
@@ -8244,6 +8488,16 @@ async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
     const phaseConfig = THERAPY_PHASES[currentPhase];
     if (turnsInPhase === 0) {
       cb?.onPhaseTransition?.(phaseConfig.name);
+      const phaseCtx = getPhaseContext(currentPhase, {
+        spec,
+        diagnosis,
+        memory: options?.memory,
+        interview: options?.interview
+      });
+      if (phaseCtx) {
+        therapistHistory.push({ role: "user", content: phaseCtx });
+        therapistHistory.push({ role: "assistant", content: "Understood. I'll incorporate this context." });
+      }
     }
     const phaseDirective = totalTurns === 0 ? `Begin with your opening. You are in the "${phaseConfig.name}" phase.` : `You are in the "${phaseConfig.name}" phase (turn ${turnsInPhase + 1}). Goals: ${phaseConfig.therapistGoals[0]}. ${turnsInPhase >= phaseConfig.minTurns ? "You may transition to the next phase when ready." : "Stay in this phase."}`;
     therapistHistory.push({ role: "user", content: `[Phase: ${phaseConfig.name}] ${phaseDirective}` });
@@ -11110,7 +11364,32 @@ async function runEvolve(spec, messages, provider, options) {
     }
   }
   if (options?.specPath) {
-    writeFileSync19(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+    const useStaging = options?.useStaging !== false;
+    if (useStaging) {
+      const stagingPath = options.specPath.replace(/\.json$/, ".staging.json");
+      writeFileSync19(stagingPath, JSON.stringify(currentSpec, null, 2) + "\n");
+      const allChanges = iterations.flatMap((i) => i.appliedChanges);
+      const diff = {
+        stagingPath,
+        changes: allChanges,
+        before: spec,
+        after: currentSpec
+      };
+      let approved = options?.autoApprove ?? false;
+      if (!approved && options?.onStagingReview) {
+        approved = await options.onStagingReview(diff);
+      }
+      if (approved) {
+        writeFileSync19(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+        try {
+          const { unlinkSync } = await import("fs");
+          unlinkSync(stagingPath);
+        } catch {
+        }
+      }
+    } else {
+      writeFileSync19(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+    }
   }
   let trainingExport;
   if (allDPOPairs.length > 0) {
@@ -12658,106 +12937,31 @@ function startFleet(config, options) {
       errors: 0
     });
   }
-  for (const agent of config.agents) {
-    let spec;
-    try {
-      spec = loadSpec(agent.specPath);
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : "Failed to load spec";
-      options.callbacks?.onError?.(agent.name, errMsg);
-      continue;
-    }
-    const agentCallbacks = {
-      onScan: (fileCount) => {
-        const status = statusMap.get(agent.name);
-        status.lastScanAt = (/* @__PURE__ */ new Date()).toISOString();
-        const event = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "scan",
-          agentName: agent.name,
-          details: { fileCount }
-        };
-        allEvents.push(event);
-        options.callbacks?.onAgentEvent?.(agent.name, event);
-      },
-      onNewFile: (filename) => {
-        const status = statusMap.get(agent.name);
-        status.filesProcessed++;
-        const event = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "new_file",
-          filename,
-          agentName: agent.name
-        };
-        allEvents.push(event);
-        options.callbacks?.onAgentEvent?.(agent.name, event);
-      },
-      onDriftDetected: (filename, severity, patterns) => {
-        const status = statusMap.get(agent.name);
-        status.driftEvents++;
-        status.lastDriftSeverity = severity;
-        const event = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "drift_detected",
-          filename,
-          agentName: agent.name,
-          details: { severity, patterns }
-        };
-        allEvents.push(event);
-        options.callbacks?.onAgentEvent?.(agent.name, event);
-      },
-      onEvolveTriggered: (filename) => {
-        const event = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "evolve_triggered",
-          filename,
-          agentName: agent.name
-        };
-        allEvents.push(event);
-        options.callbacks?.onAgentEvent?.(agent.name, event);
-      },
-      onEvolveComplete: (filename, result) => {
-        const status = statusMap.get(agent.name);
-        status.evolveCount++;
-        const event = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "evolve_complete",
-          filename,
-          agentName: agent.name,
-          details: {
-            converged: result.converged,
-            iterations: result.totalIterations,
-            dpoPairs: result.totalDPOPairs
-          }
-        };
-        allEvents.push(event);
-        options.callbacks?.onAgentEvent?.(agent.name, event);
-      },
-      onError: (filename, error) => {
-        const agentStatus = statusMap.get(agent.name);
-        agentStatus.errors++;
-        const event = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: "error",
-          filename,
-          agentName: agent.name,
-          details: error
-        };
-        allEvents.push(event);
-        options.callbacks?.onError?.(agent.name, error);
+  const concurrency = options.concurrency ?? 5;
+  const agentQueue = [...config.agents];
+  agentQueue.sort((a, b) => {
+    const aDrift = existsSync23(join21(a.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
+    const bDrift = existsSync23(join21(b.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
+    return aDrift - bDrift;
+  });
+  const agentsToStart = agentQueue.slice(0, concurrency);
+  const waitingAgents = agentQueue.slice(concurrency);
+  function startAgent(agent) {
+    startSingleAgent(agent, options, statusMap, allEvents, handles);
+  }
+  for (const agent of agentsToStart) {
+    startAgent(agent);
+  }
+  if (waitingAgents.length > 0) {
+    const originalOnError = options.callbacks?.onError;
+    options.callbacks = {
+      ...options.callbacks,
+      onError: (agentName, error) => {
+        originalOnError?.(agentName, error);
+        const next = waitingAgents.shift();
+        if (next) startAgent(next);
       }
     };
-    const handle = startWatch(spec, {
-      watchDir: agent.logDir,
-      specPath: agent.specPath,
-      provider: options.provider,
-      checkInterval: options.checkInterval,
-      threshold: options.threshold,
-      autoEvolve: options.autoEvolve,
-      maxEvolveIterations: options.maxEvolveIterations,
-      callbacks: agentCallbacks
-    });
-    handles.push({ name: agent.name, handle });
   }
   function stop() {
     for (const { handle } of handles) {
@@ -12769,6 +12973,107 @@ function startFleet(config, options) {
   }
   return { stop, getStatus, events: allEvents };
 }
+function startSingleAgent(agent, options, statusMap, allEvents, handles) {
+  let spec;
+  try {
+    spec = loadSpec(agent.specPath);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : "Failed to load spec";
+    options.callbacks?.onError?.(agent.name, errMsg);
+    return;
+  }
+  const agentCallbacks = {
+    onScan: (fileCount) => {
+      const status = statusMap.get(agent.name);
+      status.lastScanAt = (/* @__PURE__ */ new Date()).toISOString();
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "scan",
+        agentName: agent.name,
+        details: { fileCount }
+      };
+      allEvents.push(event);
+      options.callbacks?.onAgentEvent?.(agent.name, event);
+    },
+    onNewFile: (filename) => {
+      const status = statusMap.get(agent.name);
+      status.filesProcessed++;
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "new_file",
+        filename,
+        agentName: agent.name
+      };
+      allEvents.push(event);
+      options.callbacks?.onAgentEvent?.(agent.name, event);
+    },
+    onDriftDetected: (filename, severity, patterns) => {
+      const status = statusMap.get(agent.name);
+      status.driftEvents++;
+      status.lastDriftSeverity = severity;
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "drift_detected",
+        filename,
+        agentName: agent.name,
+        details: { severity, patterns }
+      };
+      allEvents.push(event);
+      options.callbacks?.onAgentEvent?.(agent.name, event);
+    },
+    onEvolveTriggered: (filename) => {
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "evolve_triggered",
+        filename,
+        agentName: agent.name
+      };
+      allEvents.push(event);
+      options.callbacks?.onAgentEvent?.(agent.name, event);
+    },
+    onEvolveComplete: (filename, result) => {
+      const status = statusMap.get(agent.name);
+      status.evolveCount++;
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "evolve_complete",
+        filename,
+        agentName: agent.name,
+        details: {
+          converged: result.converged,
+          iterations: result.totalIterations,
+          dpoPairs: result.totalDPOPairs
+        }
+      };
+      allEvents.push(event);
+      options.callbacks?.onAgentEvent?.(agent.name, event);
+    },
+    onError: (filename, error) => {
+      const agentStatus = statusMap.get(agent.name);
+      agentStatus.errors++;
+      const event = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "error",
+        filename,
+        agentName: agent.name,
+        details: error
+      };
+      allEvents.push(event);
+      options.callbacks?.onError?.(agent.name, error);
+    }
+  };
+  const handle = startWatch(spec, {
+    watchDir: agent.logDir,
+    specPath: agent.specPath,
+    provider: options.provider,
+    checkInterval: options.checkInterval,
+    threshold: options.threshold,
+    autoEvolve: options.autoEvolve,
+    maxEvolveIterations: options.maxEvolveIterations,
+    callbacks: agentCallbacks
+  });
+  handles.push({ name: agent.name, handle });
+}
 
 // src/commands/fleet.ts
 async function fleetCommand(options) {
@@ -15892,6 +16197,8 @@ Intermediate results saved to ${chalk39.cyan(".holomime/pipeline/")}`,
 }
 
 // src/commands/live.ts
+import { deflateSync } from "zlib";
+import { execSync } from "child_process";
 import chalk40 from "chalk";
 
 // src/live/agent-detector.ts
@@ -16353,12 +16660,59 @@ function startServer(port) {
 }
 
 // src/commands/live.ts
+function encodeSnapshot(event, agentName) {
+  const compact = {
+    h: event.health,
+    g: event.grade,
+    m: event.messageCount,
+    a: agentName,
+    r: event.regions.filter((r) => r.intensity > 0).map((r) => ({ i: r.id, n: Math.round(r.intensity * 100) / 100 })),
+    p: event.patterns.map((p) => ({
+      i: p.id,
+      s: p.severity,
+      c: Math.round(p.percentage * 10) / 10
+    }))
+  };
+  const json = JSON.stringify(compact);
+  const compressed = deflateSync(Buffer.from(json));
+  return compressed.toString("base64url");
+}
+function copyToClipboard(text) {
+  try {
+    if (process.platform === "darwin") {
+      execSync("pbcopy", { input: text });
+      return true;
+    } else if (process.platform === "linux") {
+      execSync("xclip -selection clipboard", { input: text });
+      return true;
+    } else if (process.platform === "win32") {
+      execSync("clip", { input: text });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function printShareLink(url, copied) {
+  console.log("");
+  console.log(
+    chalk40.green("  \u2713 ") + chalk40.bold("Brain snapshot captured!")
+  );
+  console.log("");
+  console.log("  " + chalk40.cyan(url));
+  console.log("");
+  if (copied) {
+    console.log(chalk40.dim("  Link copied to clipboard."));
+  }
+}
 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)}`);
+    console.log(
+      chalk40.green("  \u2713") + ` Manual watch: ${chalk40.dim(agent.logPath)}`
+    );
   } else {
     console.log(chalk40.dim("  Scanning for active agents..."));
     agent = detectAgent();
@@ -16366,19 +16720,69 @@ async function liveCommand(options) {
       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(
+        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"));
+      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)}`);
+    console.log(
+      chalk40.green("  \u2713") + ` Detected ${chalk40.bold(agent.agent)} session`
+    );
+    console.log(
+      chalk40.green("  \u2713") + ` Watching: ${chalk40.dim(agent.logPath)}`
+    );
+  }
+  if (options.share) {
+    console.log(chalk40.dim("  Running diagnosis for snapshot..."));
+    let resolved = false;
+    await new Promise((resolve46) => {
+      const watcher2 = startWatcher(agent, {
+        onEvent(event) {
+          if (resolved) return;
+          resolved = true;
+          watcher2.stop();
+          const encoded = encodeSnapshot(event, agent.agent);
+          const url = `https://holomime.dev/brain?d=${encoded}`;
+          const copied = copyToClipboard(url);
+          printShareLink(url, copied);
+          resolve46();
+        },
+        onError(err) {
+          console.error(chalk40.red(`
+  \u2717 Error: ${err.message}`));
+          process.exit(1);
+        },
+        onReady() {
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          watcher2.stop();
+          console.log(
+            chalk40.red("  \u2717 No diagnosis data available. Is the agent active?")
+          );
+          process.exit(1);
+        }
+      }, 1e4);
+    });
+    process.exit(0);
   }
   let server;
   try {
     server = await startServer(port);
-    console.log(chalk40.green("  \u2713") + ` NeuralSpace: ${chalk40.cyan(`http://localhost:${server.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);
@@ -16397,21 +16801,21 @@ async function liveCommand(options) {
     } catch {
     }
   }
-  let lastHealth = 100;
-  let lastPatternCount = 0;
+  let lastEvent = null;
   let msgCount = 0;
   const watcher = startWatcher(agent, {
     onEvent(event) {
       server.broadcast(event);
+      lastEvent = 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))}    `);
+      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(`
@@ -16419,13 +16823,35 @@ async function liveCommand(options) {
     },
     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(
+        chalk40.green("  \u25CF ") + chalk40.bold("Monitoring agent behavior in real-time")
+      );
+      console.log(
+        chalk40.dim("  \u2502 Press Ctrl+C to stop") + chalk40.dim(" \xB7 Press s to share snapshot")
+      );
       console.log("");
     }
   });
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      const key = data.toString();
+      if (key === "") {
+        shutdown();
+        return;
+      }
+      if ((key === "s" || key === "S") && lastEvent) {
+        const encoded = encodeSnapshot(lastEvent, agent.agent);
+        const url = `https://holomime.dev/brain?d=${encoded}`;
+        const copied = copyToClipboard(url);
+        printShareLink(url, copied);
+      }
+    });
+  }
   const shutdown = () => {
     console.log(chalk40.dim("\n\n  Stopping..."));
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
     watcher.stop();
     server.close();
     process.exit(0);
@@ -16503,11 +16929,12 @@ 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({
+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,
   port: parseInt(opts.port, 10),
   noOpen: opts.open === false,
+  share: opts.share === true,
   personality: opts.personality
 }));
 program.parseAsync().then(() => flushTelemetry());