holomime 1.5.0 → 1.6.0

package/dist/index.js

@@ -2503,26 +2503,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 = join(detectorsDir, file);
     try {
-      const raw = JSON.parse(readFileSync2(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(readFileSync2(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(readFileSync2(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
+  };
+}
 
 // src/analysis/pre-session.ts
 function runPreSessionDiagnosis(messages, spec) {
@@ -2691,13 +2750,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);
@@ -2711,6 +2777,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();
@@ -2763,7 +2842,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("; ")}`);
       }
@@ -2796,6 +2877,18 @@ function getMemoryContext(memory) {
   }
   return lines.join("\n");
 }
+function decayUnseenPatterns(memory, seenPatternIds) {
+  const seenSet = new Set(seenPatternIds);
+  for (const tracker of memory.patterns) {
+    if (!seenSet.has(tracker.patternId) && tracker.status !== "resolved") {
+      tracker.confidence = Math.max(0, (tracker.confidence ?? 0) * 0.85);
+      if (tracker.confidence < 0.05) {
+        tracker.status = "resolved";
+        tracker.confidence = 0;
+      }
+    }
+  }
+}
 function agentHandleFromSpec(spec) {
   const handle = spec.handle ?? spec.name ?? "unknown";
   return handle.toLowerCase().replace(/[^a-z0-9-]/g, "-");
@@ -4034,6 +4127,38 @@ function queryCorpus(filters, corpusPath) {
   }
   return events;
 }
+async function shareAnonymizedPatterns(report, apiKey, apiUrl = "https://holomime.dev") {
+  const key = apiKey ?? process.env.HOLOMIME_API_KEY;
+  if (!key) {
+    return { success: false, error: "No API key" };
+  }
+  try {
+    const response = await fetch(`${apiUrl}/api/v1/patterns/share`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${key}`
+      },
+      body: JSON.stringify(report)
+    });
+    if (!response.ok) {
+      return { success: false, error: `API error ${response.status}` };
+    }
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : "Network error" };
+  }
+}
+function buildAnonymizedReport(patternIds, severities, messageCount, specHash) {
+  return {
+    patterns: patternIds,
+    severities,
+    messageCount,
+    specHash,
+    version: "1.5.1",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 
 // src/analysis/diagnose-core.ts
 function runDiagnosis(messages) {
@@ -4133,6 +4258,169 @@ function runAssessment(messages, spec) {
 // src/analysis/session-runner.ts
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
 import { resolve as resolve6, join as join6 } from "path";
+
+// src/session/context-layers.ts
+function getPhaseContext(phase, input) {
+  switch (phase) {
+    case "rapport":
+      return buildRapportContext(input);
+    case "presenting_problem":
+      return buildPresentingProblemContext(input);
+    case "exploration":
+      return buildExplorationContext(input);
+    case "pattern_recognition":
+      return buildPatternRecognitionContext(input);
+    case "challenge":
+      return buildChallengeContext(input);
+    case "skill_building":
+      return buildSkillBuildingContext(input);
+    case "integration":
+      return buildIntegrationContext(input);
+    default:
+      return null;
+  }
+}
+function buildRapportContext(input) {
+  const { spec } = input;
+  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(input) {
+  const { diagnosis } = input;
+  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(input) {
+  const { diagnosis } = input;
+  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(input) {
+  const { memory } = input;
+  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(input) {
+  const { memory } = input;
+  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 (input.interview) {
+    if (input.interview.blindSpots.length > 0) {
+      lines.push(`Blind spots from interview: ${input.interview.blindSpots.join(", ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildSkillBuildingContext(input) {
+  const { diagnosis } = input;
+  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(input) {
+  const { spec, diagnosis } = input;
+  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,
@@ -4178,6 +4466,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}` });
@@ -5361,7 +5659,32 @@ async function runEvolve(spec, messages, provider, options) {
     }
   }
   if (options?.specPath) {
-    writeFileSync8(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+    const useStaging = options?.useStaging !== false;
+    if (useStaging) {
+      const stagingPath = options.specPath.replace(/\.json$/, ".staging.json");
+      writeFileSync8(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) {
+        writeFileSync8(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+        try {
+          const { unlinkSync } = await import("fs");
+          unlinkSync(stagingPath);
+        } catch {
+        }
+      }
+    } else {
+      writeFileSync8(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+    }
   }
   let trainingExport;
   if (allDPOPairs.length > 0) {
@@ -5852,6 +6175,53 @@ function generateBenchmarkMarkdown(benchmarks) {
   lines.push("");
   return lines.join("\n");
 }
+async function publishToLeaderboard(benchmark, apiKey, apiUrl = "https://holomime.dev") {
+  const key = apiKey ?? process.env.HOLOMIME_API_KEY;
+  if (!key) {
+    return { success: false, error: "No API key. Run `holomime activate` or set HOLOMIME_API_KEY." };
+  }
+  const submission = {
+    agent: benchmark.agent,
+    provider: benchmark.provider,
+    model: benchmark.model,
+    score: benchmark.score,
+    grade: benchmark.grade,
+    scenarioResults: benchmark.results.map((r) => ({
+      scenarioId: r.scenarioId,
+      passed: r.passed
+    })),
+    holomimeVersion: benchmark.metadata.holomimeVersion,
+    timestamp: benchmark.timestamp
+  };
+  try {
+    const response = await fetch(`${apiUrl}/api/v1/leaderboard/submit`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${key}`
+      },
+      body: JSON.stringify(submission)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      return { success: false, error: `API error ${response.status}: ${text}` };
+    }
+    const data = await response.json();
+    return { success: true, rank: data.rank };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : "Network error" };
+  }
+}
+async function fetchLeaderboard(limit = 50, apiUrl = "https://holomime.dev") {
+  try {
+    const response = await fetch(`${apiUrl}/api/v1/leaderboard?limit=${limit}`);
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.entries ?? [];
+  } catch {
+    return [];
+  }
+}
 function generateComparisonMarkdown(comparison) {
   const lines = [
     "## Benchmark Comparison",
@@ -6455,106 +6825,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 = existsSync11(join12(a.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
+    const bDrift = existsSync11(join12(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) {
@@ -6566,6 +6861,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/analysis/certify-core.ts
 import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync12 } from "fs";
@@ -6799,7 +7195,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -7666,6 +8062,242 @@ function resolveSpec(personality, name) {
   return personality;
 }
 
+// src/guard/middleware.ts
+function extractOpenAIResponse(response) {
+  if (response?.choices?.[0]?.message?.content) {
+    return response.choices[0].message.content;
+  }
+  if (response?.content?.[0]?.text) {
+    return response.content[0].text;
+  }
+  if (typeof response === "string") {
+    return response;
+  }
+  throw new Error(
+    "Could not extract response text. Provide a custom extractResponse function."
+  );
+}
+function injectResponseText(response, text) {
+  if (response?.choices?.[0]?.message?.content !== void 0) {
+    const cloned = JSON.parse(JSON.stringify(response));
+    cloned.choices[0].message.content = text;
+    return cloned;
+  }
+  if (response?.content?.[0]?.text !== void 0) {
+    const cloned = JSON.parse(JSON.stringify(response));
+    cloned.content[0].text = text;
+    return cloned;
+  }
+  if (typeof response === "string") {
+    return text;
+  }
+  return response;
+}
+function applyCorrections(text, patterns, _spec) {
+  let corrected = text;
+  for (const pattern of patterns) {
+    switch (pattern.id) {
+      case "over-apologizing": {
+        corrected = corrected.replace(/\bI'm (?:so |very |truly |really )?sorry(?:,| but| that| for| about| if)\b/gi, "").replace(/\bI apologize (?:for|that|if)\b/gi, "").replace(/\bMy apologies(?:,| \.)\b/gi, "").replace(/^\s*[,.]?\s*/gm, (match) => match.trim() ? match : "").replace(/\n{3,}/g, "\n\n").trim();
+        break;
+      }
+      case "hedge-stacking": {
+        const hedgePatterns = [
+          /\b(?:I think |I believe |I feel like |In my opinion, |It seems (?:like |to me )?(?:that )?)/gi,
+          /\b(?:perhaps |maybe |possibly |arguably |potentially )/gi,
+          /\b(?:sort of |kind of |more or less |to some extent )/gi
+        ];
+        const sentences = corrected.split(/(?<=[.!?])\s+/);
+        corrected = sentences.map((sentence) => {
+          let hedgeCount = 0;
+          let result = sentence;
+          for (const hp of hedgePatterns) {
+            result = result.replace(hp, (match) => {
+              hedgeCount++;
+              return hedgeCount > 1 ? "" : match;
+            });
+          }
+          return result;
+        }).join(" ").replace(/\s{2,}/g, " ").trim();
+        break;
+      }
+      case "sycophancy":
+      case "sentiment-skew": {
+        corrected = corrected.replace(/\b(?:Absolutely|Exactly|You're absolutely right|That's a great (?:question|point|idea|observation))(?:!|\.)\s*/gi, "").replace(/^\s*[,.]?\s*/gm, (match) => match.trim() ? match : "").trim();
+        break;
+      }
+    }
+  }
+  if (corrected.trim().length < 10) {
+    return text;
+  }
+  return corrected;
+}
+function createGuardMiddleware(options = {}) {
+  const mode = options.mode ?? "enforce";
+  const minSeverity = options.minSeverity ?? "warning";
+  const name = options.name ?? "Agent";
+  const maxCorrections = options.maxCorrections ?? 1;
+  let spec;
+  if (options.personality) {
+    if (typeof options.personality === "string") {
+      spec = loadSpec(options.personality);
+    } else {
+      spec = options.personality;
+    }
+  }
+  const guardChain = options.guard ?? Guard.create(name).useAll();
+  const stats = {
+    totalCalls: 0,
+    passed: 0,
+    violated: 0,
+    corrected: 0,
+    blocked: 0,
+    patternCounts: {}
+  };
+  function severityMeetsMin(severity) {
+    if (minSeverity === "warning") return severity !== "clean";
+    if (minSeverity === "concern") return severity === "concern";
+    return false;
+  }
+  function trackPatterns(patterns) {
+    for (const p of patterns) {
+      stats.patternCounts[p.id] = (stats.patternCounts[p.id] || 0) + 1;
+    }
+  }
+  function processViolation(guardResult, responseText) {
+    const violation = {
+      patterns: guardResult.patterns,
+      severity: guardResult.severity,
+      originalResponse: responseText,
+      blocked: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let finalText = responseText;
+    let corrected = false;
+    if (mode === "strict") {
+      violation.blocked = true;
+      stats.blocked++;
+      finalText = `[Response blocked by behavioral guard: ${guardResult.patterns.map((p) => p.name).join(", ")}]`;
+    } else if (mode === "enforce") {
+      let attempt = 0;
+      let current = responseText;
+      while (attempt < maxCorrections) {
+        current = applyCorrections(current, guardResult.patterns, spec);
+        attempt++;
+        const recheck = guardChain.run([
+          ...buildContextMessages(current)
+        ]);
+        if (recheck.passed || !severityMeetsMin(recheck.severity)) {
+          break;
+        }
+      }
+      if (current !== responseText) {
+        corrected = true;
+        violation.correctedResponse = current;
+        stats.corrected++;
+      }
+      finalText = current;
+    }
+    stats.violated++;
+    trackPatterns(guardResult.patterns);
+    options.onViolation?.(violation);
+    return { finalText, violation, corrected };
+  }
+  function buildContextMessages(text) {
+    return [{ role: "assistant", content: text }];
+  }
+  return {
+    guard: guardChain,
+    mode,
+    filter(conversationHistory, assistantResponse) {
+      stats.totalCalls++;
+      const allMessages = [
+        ...conversationHistory,
+        { role: "assistant", content: assistantResponse }
+      ];
+      const guardResult = guardChain.run(allMessages);
+      if (guardResult.passed || !severityMeetsMin(guardResult.severity)) {
+        stats.passed++;
+        return {
+          text: assistantResponse,
+          passed: true,
+          guardResult,
+          corrected: false
+        };
+      }
+      const { finalText, violation, corrected } = processViolation(
+        guardResult,
+        assistantResponse
+      );
+      return {
+        text: finalText,
+        passed: false,
+        guardResult,
+        violation,
+        corrected
+      };
+    },
+    async wrap(llmCall, wrapOpts) {
+      stats.totalCalls++;
+      const response = await llmCall;
+      const extract = wrapOpts?.extractResponse ?? extractOpenAIResponse;
+      const inject = wrapOpts?.injectResponse ?? injectResponseText;
+      const messages = wrapOpts?.messages ?? [];
+      let responseText;
+      try {
+        responseText = extract(response);
+      } catch {
+        stats.passed++;
+        return {
+          response,
+          passed: true,
+          guardResult: {
+            passed: true,
+            agent: name,
+            messagesAnalyzed: 0,
+            patterns: [],
+            healthy: [],
+            detectorsRun: 0,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            severity: "clean"
+          },
+          corrected: false
+        };
+      }
+      const allMessages = [
+        ...messages,
+        { role: "assistant", content: responseText }
+      ];
+      const guardResult = guardChain.run(allMessages);
+      if (guardResult.passed || !severityMeetsMin(guardResult.severity)) {
+        stats.passed++;
+        return {
+          response,
+          passed: true,
+          guardResult,
+          corrected: false
+        };
+      }
+      const { finalText, violation, corrected } = processViolation(
+        guardResult,
+        responseText
+      );
+      const finalResponse = corrected ? inject(response, finalText) : response;
+      return {
+        response: finalResponse,
+        passed: false,
+        guardResult,
+        violation,
+        corrected
+      };
+    },
+    stats() {
+      return { ...stats, patternCounts: { ...stats.patternCounts } };
+    }
+  };
+}
+
 // src/analysis/behavioral-index.ts
 function createIndexEntry(name, provider, model, configuration, report, notes) {
   return {
@@ -8658,6 +9290,181 @@ function loadAgentMessages(logDir) {
   return messages;
 }
 
+// src/compliance/audit-trail.ts
+import { readFileSync as readFileSync18, appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync12 } from "fs";
+import { join as join18, resolve as resolve15 } from "path";
+function djb2(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function hashEntry(entry) {
+  const content = `${entry.seq}|${entry.timestamp}|${entry.event}|${entry.agent}|${JSON.stringify(entry.data)}|${entry.prevHash}`;
+  return djb2(content);
+}
+function auditLogPath(agentHandle) {
+  const dir = resolve15(process.cwd(), ".holomime", "audit");
+  if (!existsSync17(dir)) mkdirSync12(dir, { recursive: true });
+  const filename = agentHandle ? `${agentHandle}-audit.jsonl` : "audit.jsonl";
+  return join18(dir, filename);
+}
+function appendAuditEntry(event, agent, data, agentHandle) {
+  const logPath = auditLogPath(agentHandle);
+  let prevHash = "genesis";
+  let seq = 1;
+  if (existsSync17(logPath)) {
+    const lines = readFileSync18(logPath, "utf-8").trim().split("\n").filter(Boolean);
+    if (lines.length > 0) {
+      try {
+        const lastEntry = JSON.parse(lines[lines.length - 1]);
+        prevHash = lastEntry.hash;
+        seq = lastEntry.seq + 1;
+      } catch {
+      }
+    }
+  }
+  const partial = {
+    seq,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    event,
+    agent,
+    data,
+    prevHash
+  };
+  const entry = {
+    ...partial,
+    hash: hashEntry(partial)
+  };
+  appendFileSync2(logPath, JSON.stringify(entry) + "\n");
+  return entry;
+}
+function loadAuditLog(agentHandle) {
+  const logPath = auditLogPath(agentHandle);
+  if (!existsSync17(logPath)) return [];
+  return readFileSync18(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+}
+function verifyAuditChain(entries) {
+  if (entries.length === 0) return true;
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const { hash, ...rest } = entry;
+    const expected = hashEntry(rest);
+    if (hash !== expected) return false;
+    if (i === 0) {
+      if (entry.prevHash !== "genesis") return false;
+    } else {
+      if (entry.prevHash !== entries[i - 1].hash) return false;
+    }
+  }
+  return true;
+}
+function generateComplianceReport(agent, from, to, agentHandle) {
+  const entries = loadAuditLog(agentHandle);
+  const fromDate = new Date(from).getTime();
+  const toDate = new Date(to).getTime();
+  const periodEntries = entries.filter((e) => {
+    const t = new Date(e.timestamp).getTime();
+    return t >= fromDate && t <= toDate;
+  });
+  const diagnoses = periodEntries.filter((e) => e.event === "diagnosis").length;
+  const sessions = periodEntries.filter((e) => e.event === "session").length;
+  const driftEvents = periodEntries.filter((e) => e.event === "drift_detected").length;
+  const guardViolations = periodEntries.filter((e) => e.event === "guard_violation").length;
+  const gradeHistory = [];
+  for (const e of periodEntries) {
+    if (e.event === "certify" || e.event === "benchmark" || e.event === "evolve") {
+      const grade = e.data.grade ?? "?";
+      const score = e.data.score ?? 0;
+      gradeHistory.push({ date: e.timestamp.split("T")[0], grade, score });
+    }
+  }
+  const avgScore = gradeHistory.length > 0 ? gradeHistory.reduce((sum, g) => sum + g.score, 0) / gradeHistory.length : 0;
+  const averageGrade = avgScore >= 90 ? "A" : avgScore >= 80 ? "B" : avgScore >= 70 ? "C" : avgScore >= 60 ? "D" : "F";
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agent,
+    period: { from, to },
+    summary: {
+      totalEvents: periodEntries.length,
+      diagnoses,
+      sessions,
+      driftEvents,
+      guardViolations,
+      averageGrade,
+      gradeHistory
+    },
+    credentials: [],
+    chainIntegrity: verifyAuditChain(entries),
+    standards: [
+      "EU AI Act Article 9 (Risk Management)",
+      "EU AI Act Article 12 (Record-keeping)",
+      "NIST AI RMF 1.0 (Govern, Map, Measure, Manage)"
+    ]
+  };
+}
+function generateMonitoringCertificate(agent, from, to, agentHandle) {
+  const report = generateComplianceReport(agent, from, to, agentHandle);
+  const scores = report.summary.gradeHistory.map((g) => g.score);
+  const minScore = scores.length > 0 ? Math.min(...scores) : 0;
+  const maxScore = scores.length > 0 ? Math.max(...scores) : 0;
+  const statement = `This certifies that AI agent "${agent}" was continuously monitored by holomime from ${from} to ${to}. During this period, the agent maintained an average behavioral alignment grade of ${report.summary.averageGrade} (scores ranging ${minScore}-${maxScore}/100). ${report.summary.driftEvents} drift events were detected and ${report.summary.sessions} therapy sessions were conducted. Audit chain integrity: ${report.chainIntegrity ? "VERIFIED" : "FAILED"}.`;
+  return {
+    agent,
+    period: { from, to },
+    maintainedGrade: report.summary.averageGrade,
+    minScore,
+    maxScore,
+    totalEvents: report.summary.totalEvents,
+    verified: report.chainIntegrity,
+    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    statement
+  };
+}
+function formatComplianceReportMarkdown(report) {
+  const lines = [
+    `# Behavioral Compliance Report \u2014 ${report.agent}`,
+    "",
+    `**Period:** ${report.period.from} to ${report.period.to}`,
+    `**Generated:** ${report.generatedAt}`,
+    `**Chain Integrity:** ${report.chainIntegrity ? "VERIFIED" : "FAILED"}`,
+    "",
+    "## Summary",
+    "",
+    `| Metric | Value |`,
+    `|--------|-------|`,
+    `| Total Events | ${report.summary.totalEvents} |`,
+    `| Diagnoses Run | ${report.summary.diagnoses} |`,
+    `| Therapy Sessions | ${report.summary.sessions} |`,
+    `| Drift Events | ${report.summary.driftEvents} |`,
+    `| Guard Violations | ${report.summary.guardViolations} |`,
+    `| Average Grade | ${report.summary.averageGrade} |`,
+    ""
+  ];
+  if (report.summary.gradeHistory.length > 0) {
+    lines.push("## Grade History", "");
+    lines.push("| Date | Grade | Score |");
+    lines.push("|------|:-----:|------:|");
+    for (const g of report.summary.gradeHistory) {
+      lines.push(`| ${g.date} | ${g.grade} | ${g.score}/100 |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Applicable Standards", "");
+  for (const s of report.standards) {
+    lines.push(`- ${s}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
 // src/core/embodiment-sync.ts
 import { z as z5 } from "zod";
 var syncAnchorSchema = z5.enum([
@@ -8719,10 +9526,12 @@ export {
   addNode,
   addSessionToMemory,
   agentHandleFromSpec,
+  appendAuditEntry,
   appendEvolution,
   applyRecommendations,
   bigFiveSchema,
   buildAgentTherapistPrompt,
+  buildAnonymizedReport,
   buildPatientSystemPrompt,
   buildReACTContext,
   buildReACTFraming,
@@ -8751,12 +9560,14 @@ export {
   corpusStats,
   createGist,
   createGraph,
+  createGuardMiddleware,
   createIndex,
   createIndexEntry,
   createMemory,
   createProvider,
   createRepertoire,
   createTreatmentPlan,
+  decayUnseenPatterns,
   deepMergeSpec,
   detectApologies,
   detectBoundaryIssues,
@@ -8780,17 +9591,21 @@ export {
   extractDPOPairsWithLLM,
   extractRLHFExamples,
   extractRecommendations,
+  fetchLeaderboard,
   fetchPersonality,
   fetchRegistry,
   findCrossAgentCorrelations,
   findEdges,
   findNode,
   findNodesByType,
+  formatComplianceReportMarkdown,
   gazePolicySchema,
   generateBenchmarkMarkdown,
   generateComparisonMarkdown,
+  generateComplianceReport,
   generateCredential,
   generateIndexMarkdown,
+  generateMonitoringCertificate,
   generatePrescriptions,
   generateProgressReport,
   generateSystemPrompt,
@@ -8808,6 +9623,7 @@ export {
   getMarketplaceClient,
   getMemoryContext,
   getNeighbors,
+  getPhaseContext,
   getScenarioById,
   getTotalSignalCount,
   graphStats,
@@ -8820,6 +9636,7 @@ export {
   listDetectors,
   listDetectorsByCategory,
   listDetectorsByTag,
+  loadAuditLog,
   loadBenchmarkResults,
   loadCorpus,
   loadCustomDetectors,
@@ -8844,6 +9661,7 @@ export {
   parseConversationLog,
   parseConversationLogFromString,
   parseJSONLLog,
+  parseMarkdownDetector,
   parseOTelGenAIExport,
   parseOpenAIAPILog,
   personalitySpecSchema,
@@ -8856,6 +9674,7 @@ export {
   prosodySchema,
   providerSchema,
   proxemicZoneSchema,
+  publishToLeaderboard,
   pushToHFHub,
   queryCorpus,
   queryInterventions,
@@ -8891,6 +9710,7 @@ export {
   selectIntervention,
   severityMeetsThreshold2 as severityMeetsThreshold,
   severitySchema,
+  shareAnonymizedPatterns,
   startFleet,
   startMCPServer,
   startWatch,
@@ -8907,6 +9727,7 @@ export {
   unregisterDetector,
   updateEdgeWeight,
   validateDetectorConfig,
+  verifyAuditChain,
   verifyCredential,
   wrapAgent
 };