holomime 1.0.0 → 1.1.0

package/dist/cli.js

@@ -2652,7 +2652,8 @@ async function validateCommand() {
 import chalk8 from "chalk";
 import figures3 from "figures";
 import { resolve as resolve5 } from "path";
-async function profileCommand() {
+import { writeFileSync as writeFileSync4 } from "fs";
+async function profileCommand(options = {}) {
   const specPath = resolve5(process.cwd(), ".personality.json");
   let raw;
   try {
@@ -2669,6 +2670,16 @@ async function profileCommand() {
     return;
   }
   const spec = parsed.data;
+  if (options.format === "md") {
+    const md = generatePersonalityMarkdown(spec);
+    if (options.output) {
+      writeFileSync4(resolve5(process.cwd(), options.output), md, "utf-8");
+      console.log(chalk8.green(`  Written to ${options.output}`));
+    } else {
+      console.log(md);
+    }
+    return;
+  }
   const bf = spec.big_five;
   const td = spec.therapy_dimensions;
   printHeader(`${spec.name} @${spec.handle}`);
@@ -2779,6 +2790,118 @@ function miniBar(score) {
 function formatEnum2(value) {
   return value.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
+function generatePersonalityMarkdown(spec) {
+  const lines = [];
+  lines.push(`# Agent Personality: ${spec.name}`);
+  lines.push("");
+  if (spec.purpose) {
+    lines.push(`> ${spec.purpose}`);
+    lines.push("");
+  }
+  lines.push(`**Handle**: \`@${spec.handle}\` | **Version**: ${spec.version}`);
+  lines.push("");
+  lines.push("## Personality (Big Five)");
+  lines.push("");
+  lines.push("| Dimension | Score | Style |");
+  lines.push("|-----------|-------|-------|");
+  const dimLabels = {
+    openness: "Openness",
+    conscientiousness: "Conscientiousness",
+    extraversion: "Extraversion",
+    agreeableness: "Agreeableness",
+    emotional_stability: "Emotional Stability"
+  };
+  for (const [key, label] of Object.entries(dimLabels)) {
+    const trait = spec.big_five[key];
+    if (trait) {
+      lines.push(`| ${label} | ${(trait.score * 100).toFixed(0)}% | ${scoreLabel(trait.score)} |`);
+    }
+  }
+  lines.push("");
+  lines.push("### Facets");
+  lines.push("");
+  for (const [key, label] of Object.entries(dimLabels)) {
+    const trait = spec.big_five[key];
+    if (!trait?.facets) continue;
+    const dimDef = DIMENSIONS.find((d) => d.id === key);
+    if (!dimDef) continue;
+    lines.push(`**${label}**`);
+    for (const facetDef of dimDef.facets) {
+      const score = trait.facets[facetDef.id];
+      if (score !== void 0) {
+        lines.push(`- ${facetDef.name}: ${(score * 100).toFixed(0)}%`);
+      }
+    }
+    lines.push("");
+  }
+  const td = spec.therapy_dimensions;
+  lines.push("## Behavioral Dimensions");
+  lines.push("");
+  lines.push(`- **Self-Awareness**: ${(td.self_awareness * 100).toFixed(0)}% (${therapyScoreLabel(td.self_awareness)})`);
+  lines.push(`- **Distress Tolerance**: ${(td.distress_tolerance * 100).toFixed(0)}% (${therapyScoreLabel(td.distress_tolerance)})`);
+  lines.push(`- **Attachment Style**: ${ATTACHMENT_STYLES[td.attachment_style].label}`);
+  lines.push(`- **Learning Orientation**: ${LEARNING_ORIENTATIONS[td.learning_orientation].label}`);
+  lines.push(`- **Boundary Awareness**: ${(td.boundary_awareness * 100).toFixed(0)}% (${therapyScoreLabel(td.boundary_awareness)})`);
+  lines.push(`- **Interpersonal Sensitivity**: ${(td.interpersonal_sensitivity * 100).toFixed(0)}% (${therapyScoreLabel(td.interpersonal_sensitivity)})`);
+  lines.push("");
+  const comm = spec.communication;
+  lines.push("## Communication Style");
+  lines.push("");
+  lines.push(`- **Register**: ${formatEnum2(comm.register)}`);
+  lines.push(`- **Output Format**: ${formatEnum2(comm.output_format)}`);
+  lines.push(`- **Emoji Policy**: ${formatEnum2(comm.emoji_policy)}`);
+  lines.push(`- **Reasoning Transparency**: ${formatEnum2(comm.reasoning_transparency)}`);
+  lines.push(`- **Conflict Approach**: ${formatEnum2(comm.conflict_approach)}`);
+  lines.push(`- **Uncertainty Handling**: ${formatEnum2(comm.uncertainty_handling)}`);
+  lines.push("");
+  if (spec.domain.expertise.length || spec.domain.boundaries.refuses.length) {
+    lines.push("## Domain & Boundaries");
+    lines.push("");
+    if (spec.domain.expertise.length) {
+      lines.push("### Expertise");
+      for (const e of spec.domain.expertise) lines.push(`- ${e}`);
+      lines.push("");
+    }
+    if (spec.domain.boundaries.refuses.length) {
+      lines.push("### Refuses");
+      for (const r of spec.domain.boundaries.refuses) lines.push(`- ${r}`);
+      lines.push("");
+    }
+    if (spec.domain.boundaries.hard_limits.length) {
+      lines.push("### Hard Limits");
+      for (const h of spec.domain.boundaries.hard_limits) lines.push(`- ${h}`);
+      lines.push("");
+    }
+  }
+  if (spec.growth.areas.length || spec.growth.strengths.length || spec.growth.patterns_to_watch.length) {
+    lines.push("## Growth");
+    lines.push("");
+    if (spec.growth.strengths.length) {
+      lines.push("### Strengths");
+      for (const s of spec.growth.strengths) lines.push(`- ${s}`);
+      lines.push("");
+    }
+    if (spec.growth.areas.length) {
+      lines.push("### Areas for Improvement");
+      for (const a of spec.growth.areas) {
+        const text = typeof a === "string" ? a : `${a.area} (${a.severity})`;
+        lines.push(`- ${text}`);
+      }
+      lines.push("");
+    }
+    if (spec.growth.patterns_to_watch.length) {
+      lines.push("### Patterns to Watch");
+      for (const p of spec.growth.patterns_to_watch) lines.push(`- ${p}`);
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by [holomime](https://holomime.dev) \u2014 regenerate with `holomime profile --format md`*");
+  lines.push("*Canonical spec: `.personality.json`*");
+  lines.push("");
+  return lines.join("\n");
+}
 
 // src/commands/diagnose.ts
 import chalk10 from "chalk";
@@ -3382,6 +3505,229 @@ function isOpenAIAPILog(data) {
   return false;
 }
 
+// src/adapters/anthropic-api.ts
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("");
+}
+function mapRole3(role) {
+  if (role === "user") return "user";
+  if (role === "system") return "system";
+  return "assistant";
+}
+function parseAnthropicAPILog(data) {
+  const items = Array.isArray(data) ? data : [data];
+  const conversations = [];
+  for (const item of items) {
+    const messages = [];
+    let model;
+    if (isRequestResponsePair(item)) {
+      const pair = item;
+      model = pair.request.model ?? pair.response.model;
+      if (pair.request.system) {
+        const systemText = extractTextContent(pair.request.system);
+        if (systemText.trim()) {
+          messages.push({ role: "system", content: systemText });
+        }
+      }
+      for (const msg of pair.request.messages) {
+        const content = extractTextContent(msg.content);
+        if (content.trim()) {
+          messages.push({ role: mapRole3(msg.role), content });
+        }
+      }
+      const responseText = extractTextContent(pair.response.content);
+      if (responseText.trim()) {
+        messages.push({ role: "assistant", content: responseText });
+      }
+    } else {
+      const resp = item;
+      model = resp.model;
+      const text = extractTextContent(resp.content);
+      if (text.trim()) {
+        messages.push({ role: "assistant", content: text });
+      }
+    }
+    if (messages.length > 0) {
+      conversations.push({
+        id: item.id ?? item.response?.id,
+        messages,
+        metadata: {
+          source: "anthropic-api",
+          ...model && { model }
+        }
+      });
+    }
+  }
+  return conversations;
+}
+function isRequestResponsePair(item) {
+  return typeof item === "object" && item !== null && "request" in item && "response" in item && typeof item.request === "object" && typeof item.response === "object";
+}
+function isAnthropicAPILog(data) {
+  if (isAnthropicResponse(data)) return true;
+  if (isRequestResponsePair(data)) return true;
+  if (Array.isArray(data) && data.length > 0) {
+    return isAnthropicResponse(data[0]) || isRequestResponsePair(data[0]);
+  }
+  return false;
+}
+function isAnthropicResponse(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const obj = data;
+  return obj.type === "message" && Array.isArray(obj.content);
+}
+
+// src/adapters/otel-genai.ts
+function getAttr(attrs, key) {
+  if (!attrs) return void 0;
+  const attr = attrs.find((a) => a.key === key);
+  if (!attr) return void 0;
+  return attr.value.stringValue ?? (attr.value.intValue != null ? String(attr.value.intValue) : void 0);
+}
+function hasGenAIAttrs(attrs) {
+  if (!attrs) return false;
+  return attrs.some((a) => a.key.startsWith("gen_ai."));
+}
+function mapRole4(role) {
+  if (role === "user") return "user";
+  if (role === "system") return "system";
+  return "assistant";
+}
+function nanoToISO(nano) {
+  if (!nano) return void 0;
+  const ms = Number(BigInt(nano) / BigInt(1e6));
+  return new Date(ms).toISOString();
+}
+function parseOTelGenAIExport(data) {
+  const traceMap = /* @__PURE__ */ new Map();
+  for (const rs of data.resourceSpans) {
+    for (const ss of rs.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        if (!hasGenAIAttrs(span.attributes)) continue;
+        const traceId = span.traceId;
+        if (!traceMap.has(traceId)) {
+          traceMap.set(traceId, { messages: [] });
+        }
+        const trace = traceMap.get(traceId);
+        const system = getAttr(span.attributes, "gen_ai.system");
+        const model = getAttr(span.attributes, "gen_ai.request.model");
+        if (system) trace.system = system;
+        if (model) trace.model = model;
+        const timestamp = nanoToISO(span.startTimeUnixNano);
+        const messagesAttr = span.attributes?.find((a) => a.key === "gen_ai.request.messages");
+        if (messagesAttr?.value.stringValue) {
+          try {
+            const parsed = JSON.parse(messagesAttr.value.stringValue);
+            if (Array.isArray(parsed)) {
+              for (const m of parsed) {
+                if (m.role && m.content) {
+                  trace.messages.push({
+                    role: mapRole4(m.role),
+                    content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+                    ...timestamp && { timestamp }
+                  });
+                }
+              }
+              continue;
+            }
+          } catch {
+          }
+        }
+        const promptContent = getAttr(span.attributes, "gen_ai.prompt.0.content");
+        const completionContent = getAttr(span.attributes, "gen_ai.completion.0.content");
+        if (promptContent) {
+          trace.messages.push({
+            role: "user",
+            content: promptContent,
+            ...timestamp && { timestamp }
+          });
+        }
+        if (completionContent) {
+          trace.messages.push({
+            role: "assistant",
+            content: completionContent,
+            ...timestamp && { timestamp }
+          });
+        }
+      }
+    }
+  }
+  const conversations = [];
+  for (const [traceId, trace] of traceMap) {
+    if (trace.messages.length === 0) continue;
+    conversations.push({
+      id: traceId,
+      messages: trace.messages,
+      metadata: {
+        source: "otel",
+        ...trace.system && { system: trace.system },
+        ...trace.model && { model: trace.model }
+      }
+    });
+  }
+  return conversations;
+}
+function isOTelGenAIExport(data) {
+  if (typeof data !== "object" || data === null) return false;
+  if (!("resourceSpans" in data) || !Array.isArray(data.resourceSpans)) return false;
+  const rs = data.resourceSpans;
+  for (const r of rs) {
+    for (const ss of r.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        if (hasGenAIAttrs(span.attributes)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/adapters/jsonl.ts
+function mapRole5(role) {
+  if (role === "user") return "user";
+  if (role === "system") return "system";
+  return "assistant";
+}
+function parseJSONLLog(raw) {
+  const lines = raw.split("\n").filter((l) => l.trim() !== "");
+  const convMap = /* @__PURE__ */ new Map();
+  const defaultKey = "__default__";
+  for (const line of lines) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) continue;
+    if (typeof parsed.role !== "string" || typeof parsed.content !== "string") continue;
+    const convId = typeof parsed.conversation_id === "string" ? parsed.conversation_id : defaultKey;
+    if (!convMap.has(convId)) {
+      convMap.set(convId, []);
+    }
+    const message = {
+      role: mapRole5(parsed.role),
+      content: parsed.content
+    };
+    if (typeof parsed.timestamp === "string") {
+      message.timestamp = parsed.timestamp;
+    } else if (typeof parsed.timestamp === "number") {
+      message.timestamp = new Date(parsed.timestamp * 1e3).toISOString();
+    }
+    convMap.get(convId).push(message);
+  }
+  const conversations = [];
+  for (const [key, messages] of convMap) {
+    if (messages.length === 0) continue;
+    conversations.push({
+      ...key !== defaultKey && { id: key },
+      messages,
+      metadata: { source: "jsonl" }
+    });
+  }
+  return conversations;
+}
+
 // src/adapters/log-adapter.ts
 function parseConversationLog(raw, format = "auto") {
   if (format === "holomime") {
@@ -3397,6 +3743,16 @@ function parseConversationLog(raw, format = "auto") {
   if (format === "openai-api") {
     return parseOpenAIAPILog(raw);
   }
+  if (format === "anthropic-api") {
+    return parseAnthropicAPILog(raw);
+  }
+  if (format === "otel") {
+    return parseOTelGenAIExport(raw);
+  }
+  if (format === "jsonl") {
+    if (typeof raw !== "string") throw new Error("JSONL format expects a raw string (not parsed JSON)");
+    return parseJSONLLog(raw);
+  }
   const holomimeResult = conversationLogSchema.safeParse(raw);
   if (holomimeResult.success) {
     const log = holomimeResult.data;
@@ -3408,11 +3764,17 @@ function parseConversationLog(raw, format = "auto") {
   if (isClaudeExport(raw)) {
     return parseClaudeExport(raw);
   }
+  if (isAnthropicAPILog(raw)) {
+    return parseAnthropicAPILog(raw);
+  }
   if (isOpenAIAPILog(raw)) {
     return parseOpenAIAPILog(raw);
   }
+  if (isOTelGenAIExport(raw)) {
+    return parseOTelGenAIExport(raw);
+  }
   throw new Error(
-    "Unrecognized log format. Supported: holomime, chatgpt, claude, openai-api. Use --format to specify explicitly."
+    "Unrecognized log format. Supported: holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl. Use --format to specify explicitly."
   );
 }
 function parseHolomime(raw) {
@@ -3513,7 +3875,7 @@ async function diagnoseCommand(options) {
 // src/commands/assess.ts
 import chalk11 from "chalk";
 import figures6 from "figures";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import { resolve as resolve7, join as join2 } from "path";
 
 // src/analysis/trait-scorer.ts
@@ -3754,7 +4116,7 @@ async function assessCommand(options) {
   };
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filepath = join2(assessDir, `${date}.json`);
-  writeFileSync4(filepath, JSON.stringify(snapshot, null, 2));
+  writeFileSync5(filepath, JSON.stringify(snapshot, null, 2));
   console.log(chalk11.dim(`  Assessment saved: ${filepath}`));
   if (warnings.length > 0) {
     showSoftUpsell("assess");
@@ -3766,7 +4128,7 @@ async function assessCommand(options) {
 import chalk14 from "chalk";
 import figures7 from "figures";
 import { createInterface } from "readline";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
 import { resolve as resolve9 } from "path";
 
 // src/analysis/pre-session.ts
@@ -3855,7 +4217,7 @@ function runPreSessionDiagnosis(messages, spec) {
 }
 
 // src/analysis/session-runner.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
 import { resolve as resolve8, join as join3 } from "path";
 
 // src/analysis/therapy-protocol.ts
@@ -4287,7 +4649,7 @@ function saveTranscript(transcript, agentName) {
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}-${slug}.json`;
   const filepath = join3(dir, filename);
-  writeFileSync5(filepath, JSON.stringify(transcript, null, 2));
+  writeFileSync6(filepath, JSON.stringify(transcript, null, 2));
   return filepath;
 }
 
@@ -4778,7 +5140,7 @@ Exchanges: ${Math.floor(transcript.turns.filter((t) => t.speaker !== "supervisor
       const specPath = resolve9(process.cwd(), ".personality.json");
       const { changed, changes } = applyRecommendations(spec, diagnosis);
       if (changed) {
-        writeFileSync6(specPath, JSON.stringify(spec, null, 2) + "\n");
+        writeFileSync7(specPath, JSON.stringify(spec, null, 2) + "\n");
         console.log();
         printBox(`${figures7.tick} Applied session recommendations to .personality.json`, "success", "Applied");
         console.log();
@@ -4889,7 +5251,7 @@ import { readdirSync, existsSync as existsSync6 } from "fs";
 import { resolve as resolve11, join as join5 } from "path";
 
 // src/analysis/evolution-history.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
 import { resolve as resolve10 } from "path";
 function getEvolutionPath() {
   return resolve10(process.cwd(), ".holomime", "evolution.json");
@@ -4925,7 +5287,7 @@ function appendEvolution(entry, agentName) {
   history.totalSessions = history.entries.length;
   history.totalDPOPairs = history.entries.reduce((sum, e) => sum + e.dpoPairsExtracted, 0);
   history.lastSession = entry.timestamp;
-  writeFileSync7(filepath, JSON.stringify(history, null, 2) + "\n");
+  writeFileSync8(filepath, JSON.stringify(history, null, 2) + "\n");
 }
 function getEvolutionSummary(history) {
   const entries = history.entries;
@@ -5190,7 +5552,7 @@ async function browseCommand(options) {
 // src/commands/pull.ts
 import chalk17 from "chalk";
 import figures9 from "figures";
-import { writeFileSync as writeFileSync8, existsSync as existsSync7 } from "fs";
+import { writeFileSync as writeFileSync9, existsSync as existsSync7 } from "fs";
 import { resolve as resolve12 } from "path";
 import { select as select2 } from "@inquirer/prompts";
 async function pullCommand(handle, options) {
@@ -5241,7 +5603,7 @@ async function pullCommand(handle, options) {
       return;
     }
   }
-  writeFileSync8(outputPath, JSON.stringify(result.data, null, 2) + "\n");
+  writeFileSync9(outputPath, JSON.stringify(result.data, null, 2) + "\n");
   console.log();
   printBox(`${figures9.tick} Pulled ${entry.name} (@${entry.handle}) to ${outputPath}`, "success");
   console.log();
@@ -5333,7 +5695,7 @@ import { readFileSync as readFileSync9 } from "fs";
 import { resolve as resolve14 } from "path";
 
 // src/analysis/autopilot-core.ts
-import { writeFileSync as writeFileSync9 } from "fs";
+import { writeFileSync as writeFileSync10 } from "fs";
 var SEVERITY_ORDER = ["routine", "targeted", "intervention"];
 function severityMeetsThreshold(severity, threshold) {
   const severityIdx = SEVERITY_ORDER.indexOf(severity);
@@ -5370,7 +5732,7 @@ async function runAutopilot(spec, messages, provider, options) {
   const specCopy = JSON.parse(JSON.stringify(spec));
   const { changed, changes } = applyRecommendations(specCopy, diagnosis);
   if (changed && options?.specPath) {
-    writeFileSync9(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
+    writeFileSync10(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
   }
   saveTranscript(transcript, spec.name ?? "Agent");
   return {
@@ -5540,7 +5902,7 @@ async function autopilotCommand(options) {
 // src/commands/export.ts
 import chalk20 from "chalk";
 import figures12 from "figures";
-import { writeFileSync as writeFileSync10 } from "fs";
+import { writeFileSync as writeFileSync11 } from "fs";
 import { resolve as resolve15 } from "path";
 
 // src/analysis/training-export.ts
@@ -5891,12 +6253,12 @@ Run ${chalk20.cyan("holomime session")} first to generate session transcripts.`,
   mkdirSync15(dir, { recursive: true });
   if (format === "huggingface" || format === "openai") {
     const jsonl = convertToHFFormat(result);
-    writeFileSync10(fullPath, jsonl);
+    writeFileSync11(fullPath, jsonl);
   } else if (format === "jsonl") {
     const lines = result.examples.map((ex) => JSON.stringify(ex)).join("\n");
-    writeFileSync10(fullPath, lines + "\n");
+    writeFileSync11(fullPath, lines + "\n");
   } else {
-    writeFileSync10(fullPath, JSON.stringify(result, null, 2) + "\n");
+    writeFileSync11(fullPath, JSON.stringify(result, null, 2) + "\n");
   }
   console.log(`  ${chalk20.green(figures12.tick)} Written to ${chalk20.cyan(outputPath)}`);
   console.log();
@@ -5981,7 +6343,7 @@ This is the closed-loop behavioral alignment system.`,
 // src/commands/train.ts
 import chalk21 from "chalk";
 import figures13 from "figures";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync13, mkdirSync as mkdirSync7, readdirSync as readdirSync3, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync14, mkdirSync as mkdirSync7, readdirSync as readdirSync3, existsSync as existsSync9 } from "fs";
 import { resolve as resolve19, join as join9 } from "path";
 
 // src/analysis/train-provider.ts
@@ -6193,7 +6555,7 @@ var OpenAITrainProvider = class {
 
 // src/analysis/train-huggingface.ts
 import { spawn } from "child_process";
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync5 } from "fs";
+import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync5 } from "fs";
 import { resolve as resolve17, join as join7 } from "path";
 import { createInterface as createInterface2 } from "readline";
 async function checkPythonDeps() {
@@ -6226,7 +6588,7 @@ function writeHFTrainingFile(data) {
   const tmpDir = resolve17(process.cwd(), ".holomime/tmp");
   mkdirSync5(tmpDir, { recursive: true });
   const filePath = join7(tmpDir, `hf-train-${Date.now()}.json`);
-  writeFileSync11(filePath, JSON.stringify(data, null, 2));
+  writeFileSync12(filePath, JSON.stringify(data, null, 2));
   return filePath;
 }
 var HuggingFaceTrainProvider = class {
@@ -6345,7 +6707,7 @@ var HuggingFaceTrainProvider = class {
 
 // src/analysis/train-eval.ts
 import { spawn as spawn2 } from "child_process";
-import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync6 } from "fs";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync6 } from "fs";
 import { resolve as resolve18, join as join8 } from "path";
 import { createInterface as createInterface3 } from "readline";
 
@@ -6596,7 +6958,7 @@ async function runHFAutoEval(baseModel, fineTunedModel, agentName, data, onProgr
   const tmpDir = resolve18(process.cwd(), ".holomime/tmp");
   mkdirSync6(tmpDir, { recursive: true });
   const promptsPath = join8(tmpDir, `eval-prompts-${Date.now()}.json`);
-  writeFileSync12(promptsPath, JSON.stringify(prompts));
+  writeFileSync13(promptsPath, JSON.stringify(prompts));
   const scriptPath = resolve18(
     new URL(".", import.meta.url).pathname,
     "../../scripts/eval_hf.py"
@@ -6691,7 +7053,7 @@ function deployModel(result, personalityPath) {
     deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
     personalityPath
   };
-  writeFileSync13(
+  writeFileSync14(
     join9(trainingDir, "latest.json"),
     JSON.stringify(record, null, 2) + "\n"
   );
@@ -6706,7 +7068,7 @@ function deployModel(result, personalityPath) {
       examples: result.examples,
       trained_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync13(fullPath, JSON.stringify(spec, null, 2) + "\n");
+    writeFileSync14(fullPath, JSON.stringify(spec, null, 2) + "\n");
   }
 }
 async function trainCommand(options) {
@@ -7062,7 +7424,7 @@ import { readFileSync as readFileSync14 } from "fs";
 import { resolve as resolve21 } from "path";
 
 // src/analysis/evolve-core.ts
-import { writeFileSync as writeFileSync14 } from "fs";
+import { writeFileSync as writeFileSync15 } from "fs";
 async function runEvolve(spec, messages, provider, options) {
   const maxIterations = options?.maxIterations ?? 5;
   const convergenceThreshold = options?.convergenceThreshold ?? 85;
@@ -7175,7 +7537,7 @@ async function runEvolve(spec, messages, provider, options) {
     }
   }
   if (options?.specPath) {
-    writeFileSync14(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+    writeFileSync15(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
   }
   let trainingExport;
   if (allDPOPairs.length > 0) {
@@ -7187,7 +7549,7 @@ async function runEvolve(spec, messages, provider, options) {
       generated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (options?.exportDpoPath) {
-      writeFileSync14(options.exportDpoPath, JSON.stringify(trainingExport, null, 2) + "\n");
+      writeFileSync15(options.exportDpoPath, JSON.stringify(trainingExport, null, 2) + "\n");
     }
   }
   return {
@@ -7599,7 +7961,7 @@ function gradeFromScore2(score) {
 }
 
 // src/analysis/benchmark-publish.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync15, existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync4 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync16, existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync4 } from "fs";
 import { join as join10 } from "path";
 import { homedir as homedir2 } from "os";
 function getBenchmarkDir(outputDir) {
@@ -7630,7 +7992,7 @@ function saveBenchmarkResult(report, outputDir) {
       scenarioCount: report.results.length
     }
   };
-  writeFileSync15(filepath, JSON.stringify(published, null, 2));
+  writeFileSync16(filepath, JSON.stringify(published, null, 2));
   return filepath;
 }
 function loadBenchmarkResults(dir) {
@@ -7858,7 +8220,7 @@ import { existsSync as existsSync12 } from "fs";
 import { resolve as resolve24 } from "path";
 
 // src/analysis/watch-core.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync17, writeFileSync as writeFileSync16, mkdirSync as mkdirSync9, existsSync as existsSync11 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync17, writeFileSync as writeFileSync17, mkdirSync as mkdirSync9, existsSync as existsSync11 } from "fs";
 import { join as join11, resolve as resolve23 } from "path";
 var SEVERITY_ORDER2 = ["routine", "targeted", "intervention"];
 function severityMeetsThreshold2(severity, threshold) {
@@ -7960,7 +8322,7 @@ function startWatch(spec, options) {
     if (!existsSync11(logDir)) {
       mkdirSync9(logDir, { recursive: true });
     }
-    writeFileSync16(
+    writeFileSync17(
       join11(logDir, "watch-log.json"),
       JSON.stringify({ events, stoppedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
     );
@@ -8108,7 +8470,7 @@ import { readFileSync as readFileSync19 } from "fs";
 import { resolve as resolve26 } from "path";
 
 // src/analysis/certify-core.ts
-import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
+import { writeFileSync as writeFileSync18, mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
 import { join as join12, resolve as resolve25 } from "path";
 function djb2Hash(str) {
   let hash = 0;
@@ -8229,7 +8591,7 @@ function saveCredential(credential, outputDir) {
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${credential.agent.handle}-${date}.json`;
   const filepath = join12(dir, filename);
-  writeFileSync17(filepath, JSON.stringify(credential, null, 2) + "\n");
+  writeFileSync18(filepath, JSON.stringify(credential, null, 2) + "\n");
   return filepath;
 }
 
@@ -8349,7 +8711,7 @@ async function certifyCommand(options) {
 
 // src/commands/daemon.ts
 import chalk27 from "chalk";
-import { writeFileSync as writeFileSync18, readFileSync as readFileSync20, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
+import { writeFileSync as writeFileSync19, readFileSync as readFileSync20, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
 import { resolve as resolve27 } from "path";
 var HOLOMIME_DIR = ".holomime";
 function getDaemonStatePath() {
@@ -8366,7 +8728,7 @@ function ensureDir() {
 }
 function writeDaemonState(state) {
   ensureDir();
-  writeFileSync18(getDaemonStatePath(), JSON.stringify(state, null, 2) + "\n");
+  writeFileSync19(getDaemonStatePath(), JSON.stringify(state, null, 2) + "\n");
 }
 function appendDaemonLog(event) {
   ensureDir();
@@ -8380,7 +8742,7 @@ function appendDaemonLog(event) {
     log = [];
   }
   log.push(event);
-  writeFileSync18(logPath, JSON.stringify(log, null, 2) + "\n");
+  writeFileSync19(logPath, JSON.stringify(log, null, 2) + "\n");
 }
 async function daemonCommand(options) {
   printHeader("Daemon Mode");
@@ -8541,7 +8903,7 @@ Log: ${getDaemonLogPath()}`,
 // src/commands/fleet.ts
 import chalk28 from "chalk";
 import figures19 from "figures";
-import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync12, existsSync as existsSync16 } from "fs";
+import { writeFileSync as writeFileSync20, mkdirSync as mkdirSync12, existsSync as existsSync16 } from "fs";
 import { resolve as resolve29, join as join15 } from "path";
 
 // src/analysis/fleet-core.ts
@@ -8824,7 +9186,7 @@ Press Ctrl+C for fleet summary`,
       mkdirSync12(logDir, { recursive: true });
     }
     const logPath = join15(logDir, "fleet-log.json");
-    writeFileSync19(
+    writeFileSync20(
       logPath,
       JSON.stringify({
         stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8845,7 +9207,7 @@ Press Ctrl+C for fleet summary`,
 // src/commands/activate.ts
 import chalk30 from "chalk";
 import figures20 from "figures";
-import { writeFileSync as writeFileSync21, mkdirSync as mkdirSync14, existsSync as existsSync18 } from "fs";
+import { writeFileSync as writeFileSync22, mkdirSync as mkdirSync14, existsSync as existsSync18 } from "fs";
 import { join as join17 } from "path";
 import { homedir as homedir4 } from "os";
 
@@ -8853,7 +9215,7 @@ import { homedir as homedir4 } from "os";
 import { PostHog } from "posthog-node";
 
 // src/telemetry/config.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync20, mkdirSync as mkdirSync13, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync21, mkdirSync as mkdirSync13, existsSync as existsSync17 } from "fs";
 import { join as join16 } from "path";
 import { homedir as homedir3 } from "os";
 import { randomUUID } from "crypto";
@@ -8877,7 +9239,7 @@ function readConfig() {
 }
 function writeConfig(config) {
   ensureDir2();
-  writeFileSync20(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+  writeFileSync21(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
 function shouldTrack() {
   if (process.env.HOLOMIME_TELEMETRY === "0") return false;
@@ -8898,7 +9260,7 @@ function getAnonymousId() {
   }
   const id = randomUUID();
   ensureDir2();
-  writeFileSync20(ANON_ID_PATH, id);
+  writeFileSync21(ANON_ID_PATH, id);
   return id;
 }
 function showTelemetryBannerIfNeeded() {
@@ -8992,7 +9354,7 @@ async function activateCommand(key) {
   if (!existsSync18(holomimeDir)) {
     mkdirSync14(holomimeDir, { recursive: true });
   }
-  writeFileSync21(licensePath, trimmedKey);
+  writeFileSync22(licensePath, trimmedKey);
   console.log(chalk30.dim("  Validating license..."));
   const result = await validateLicense(trimmedKey);
   if (result.valid) {
@@ -9091,21 +9453,21 @@ program.name("holomime").description("Personality engine for AI agents \u2014 Bi
 program.command("init").description("Build a personality profile through a guided assessment").action(initCommand);
 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)", "chat").option("--for <format>", "Compile for a specific format (openclaw)").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);
-program.command("profile").description("Pretty-print a human-readable personality summary").action(profileCommand);
-program.command("diagnose").description("Detect behavioral patterns from conversation logs (rule-based, no LLM)").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").action(diagnoseCommand);
-program.command("assess").description("Full Big Five alignment check \u2014 compare spec vs actual behavior").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").action(assessCommand);
+program.command("profile").description("Pretty-print a human-readable personality summary").option("--format <format>", "Output format (terminal, md)", "terminal").option("-o, --output <path>", "Write output to file (for md format)").action(profileCommand);
+program.command("diagnose").description("Detect behavioral patterns from conversation logs (rule-based, no LLM)").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").action(diagnoseCommand);
+program.command("assess").description("Full Big Five alignment check \u2014 compare spec vs actual behavior").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Path to conversation log (JSON)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").action(assessCommand);
 program.command("browse").description("Browse shared personality profiles from the community registry").option("--tag <tag>", "Filter by tag").action(browseCommand);
 program.command("pull").description("Download a personality profile from the registry").argument("<handle>", "Personality handle to pull").option("-o, --output <path>", "Output path", ".personality.json").action(pullCommand);
 program.command("publish").description("Share your personality profile to the community registry").option("--personality <path>", "Path to .personality.json", ".personality.json").action(publishCommand);
 program.command("activate").description("Activate a Pro license key").argument("<key>", "License key from holomime.dev").action(activateCommand);
 program.command("telemetry").description("Manage anonymous usage telemetry").argument("[action]", "enable, disable, or status (default: status)").action(telemetryCommand);
-program.command("session").description("Live alignment session \u2014 behavioral refinement for your agent [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override (e.g. claude-sonnet-4-20250514, gpt-4o)").option("--log <path>", "Conversation log for pre-session diagnosis").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").option("--turns <n>", "Maximum session turns", "24").option("--observe", "Observe mode (watch without intervention)").option("--interactive", "Supervisor mode \u2014 intervene mid-session with directives").option("--apply", "Apply recommendations to .personality.json after session").action(sessionCommand);
-program.command("autopilot").description("Automated behavioral alignment \u2014 diagnose, refine, and apply [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").option("--threshold <level>", "Trigger threshold (routine, targeted, intervention)", "targeted").option("--turns <n>", "Maximum session turns", "24").option("--dry-run", "Show what would happen without running alignment").option("--apply", "Apply recommendations to .personality.json after session").action(autopilotCommand);
+program.command("session").description("Live alignment session \u2014 behavioral refinement for your agent [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override (e.g. claude-sonnet-4-20250514, gpt-4o)").option("--log <path>", "Conversation log for pre-session diagnosis").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").option("--turns <n>", "Maximum session turns", "24").option("--observe", "Observe mode (watch without intervention)").option("--interactive", "Supervisor mode \u2014 intervene mid-session with directives").option("--apply", "Apply recommendations to .personality.json after session").action(sessionCommand);
+program.command("autopilot").description("Automated behavioral alignment \u2014 diagnose, refine, and apply [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").option("--threshold <level>", "Trigger threshold (routine, targeted, intervention)", "targeted").option("--turns <n>", "Maximum session turns", "24").option("--dry-run", "Show what would happen without running alignment").option("--apply", "Apply recommendations to .personality.json after session").action(autopilotCommand);
 program.command("growth").description("Track improvement over time from assessment history [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--history <path>", "Path to assessments directory", ".holomime/assessments").action(growthCommand);
 program.command("export").description("Export alignment sessions as training data (DPO, RLHF, Alpaca, HuggingFace, OpenAI) [Pro]").requiredOption("--format <format>", "Export format (dpo, rlhf, jsonl, alpaca, huggingface, openai)").option("--sessions <path>", "Path to sessions directory", ".holomime/sessions").option("-o, --output <path>", "Output file path").option("--push", "Push to HuggingFace Hub after export (requires HF_TOKEN)").option("--repo <repo>", "HuggingFace Hub repo name for push (e.g. user/dataset-name)").action(exportCommand);
 program.command("train").description("Fine-tune a model with alignment data \u2014 train, deploy, and verify [Pro]").option("--data <path>", "Path to exported training data").option("--provider <provider>", "Training provider (openai, huggingface)", "openai").option("--base-model <model>", "Base model to fine-tune", "gpt-4o-mini").option("--suffix <suffix>", "Model name suffix").option("--epochs <n>", "Training epochs").option("--method <method>", "Training method (auto, sft, dpo)", "auto").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--skip-eval", "Skip auto-evaluation after training").option("--skip-deploy", "Skip auto-deploy to personality").option("--dry-run", "Preview training plan without starting").option("--push", "Push trained model to HuggingFace Hub (HF only)").option("--hub-repo <repo>", "HuggingFace Hub repo name for push (e.g. user/model-name)").action(trainCommand);
-program.command("eval").description("Measure alignment effectiveness \u2014 compare before/after behavior [Pro]").requiredOption("--before <path>", "Conversation log from BEFORE alignment").requiredOption("--after <path>", "Conversation log from AFTER alignment").option("--personality <path>", "Path to .personality.json (for agent name)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").action(evalCommand);
-program.command("evolve").description("Recursive behavioral alignment \u2014 iterate until converged [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api)", "auto").option("--max-iterations <n>", "Maximum alignment iterations", "5").option("--convergence <score>", "TES convergence threshold (0-100)", "85").option("--turns <n>", "Max turns per session", "18").option("--apply", "Apply final recommendations to .personality.json").option("--export-dpo <path>", "Export accumulated DPO pairs to file").option("--dry-run", "Preview without running sessions").action(evolveCommand);
+program.command("eval").description("Measure alignment effectiveness \u2014 compare before/after behavior [Pro]").requiredOption("--before <path>", "Conversation log from BEFORE alignment").requiredOption("--after <path>", "Conversation log from AFTER alignment").option("--personality <path>", "Path to .personality.json (for agent name)").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").action(evalCommand);
+program.command("evolve").description("Recursive behavioral alignment \u2014 iterate until converged [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--log <path>", "Conversation log for diagnosis").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--format <format>", "Log format (auto, holomime, chatgpt, claude, openai-api, anthropic-api, otel, jsonl)", "auto").option("--max-iterations <n>", "Maximum alignment iterations", "5").option("--convergence <score>", "TES convergence threshold (0-100)", "85").option("--turns <n>", "Max turns per session", "18").option("--apply", "Apply final recommendations to .personality.json").option("--export-dpo <path>", "Export accumulated DPO pairs to file").option("--dry-run", "Preview without running sessions").action(evolveCommand);
 program.command("benchmark").description("Behavioral stress test \u2014 7 scenarios targeting each detector [Pro]").requiredOption("--personality <path>", "Path to .personality.json").option("--provider <provider>", "LLM provider (ollama, anthropic, openai)", "ollama").option("--model <model>", "Model override").option("--scenarios <list>", "Comma-separated scenario filter (e.g. apology-trap,sycophancy-test)").action(benchmarkCommand);
 program.command("watch").description("Continuous drift detection \u2014 monitor logs and auto-align [Pro]").requiredOption("--personality <path>", "Path to .personality.json").requiredOption("--dir <path>", "Directory to watch for conversation logs").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(watchCommand);
 program.command("certify").description("Generate a verifiable behavioral credential for your agent [Pro]").option("--personality <path>", "Path to .personality.json", ".personality.json").option("--benchmark <path>", "Path to benchmark report JSON").option("--evolve <path>", "Path to evolve result JSON").option("-o, --output <path>", "Output directory for credential").option("--verify <path>", "Verify an existing credential").action(certifyCommand);