holomime 1.9.2 → 2.1.0

package/dist/index.js

@@ -4373,7 +4373,7 @@ function queryCorpus(filters, corpusPath) {
   }
   return events;
 }
-async function shareAnonymizedPatterns(report, apiKey, apiUrl = "https://holomime.dev") {
+async function shareAnonymizedPatterns(report, apiKey, apiUrl = "https://holomime.com") {
   const key = apiKey ?? process.env.HOLOMIME_API_KEY;
   if (!key) {
     return { success: false, error: "No API key" };
@@ -4503,8 +4503,8 @@ 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";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync8 } from "fs";
+import { resolve as resolve7, join as join8 } from "path";
 
 // src/session/context-layers.ts
 function getPhaseContext(phase, input) {
@@ -4667,6 +4667,679 @@ function buildIntegrationContext(input) {
   return lines.join("\n");
 }
 
+// src/analysis/stack-patcher.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+
+// src/core/stack-types.ts
+import { z as z4 } from "zod";
+var soulFrontmatterSchema = z4.object({
+  version: z4.string().default("1.0"),
+  immutable: z4.boolean().default(true)
+});
+var soulSchema = z4.object({
+  frontmatter: soulFrontmatterSchema,
+  name: z4.string().min(1).max(100),
+  purpose: z4.string().max(500).optional(),
+  core_values: z4.array(z4.string()).default([]),
+  red_lines: z4.array(z4.string()).default([]),
+  ethical_framework: z4.string().optional()
+});
+var mindSchema = z4.object({
+  version: z4.string().default("1.0"),
+  big_five: bigFiveSchema,
+  therapy_dimensions: therapyDimensionsSchema,
+  communication: communicationSchema.default({}),
+  growth: growthSchema.default({})
+});
+var purposeSchema = z4.object({
+  version: z4.string().default("1.0"),
+  role: z4.string().default("General-purpose AI assistant"),
+  objectives: z4.array(z4.string()).default(["Help users accomplish their goals"]),
+  domain: z4.array(z4.string()).default(["general"]),
+  stakeholders: z4.array(z4.string()).default(["end-users"]),
+  success_criteria: z4.array(z4.string()).default(["Task completion accuracy"]),
+  context: z4.string().default("Production deployment")
+});
+var hardwareProfileSchema = z4.object({
+  oem: z4.string().optional(),
+  model: z4.string().optional(),
+  actuator_count: z4.number().int().optional(),
+  sensors: z4.array(z4.string()).default([]),
+  compute: z4.enum(["onboard", "edge", "cloud", "hybrid"]).default("onboard")
+});
+var bodySchema = z4.object({
+  version: z4.string().default("1.0"),
+  morphology: morphologySchema.default("humanoid"),
+  modalities: z4.array(modalitySchema).default(["gesture", "gaze", "voice", "posture"]),
+  safety_envelope: safetyEnvelopeSchema.default({}),
+  expression: expressionSchema.optional(),
+  hardware_profile: hardwareProfileSchema.optional()
+});
+var conscienceRuleSchema = z4.object({
+  action: z4.string(),
+  reason: z4.string().optional(),
+  conditions: z4.array(z4.string()).optional()
+});
+var escalationRuleSchema = z4.object({
+  trigger: z4.string(),
+  action: z4.string(),
+  severity: z4.enum(["info", "warning", "critical"]).default("warning")
+});
+var conscienceSchema = z4.object({
+  version: z4.string().default("1.0"),
+  rules: z4.object({
+    deny: z4.array(conscienceRuleSchema).default([]),
+    allow: z4.array(conscienceRuleSchema).default([]),
+    escalate: z4.array(escalationRuleSchema).default([])
+  }).default({}),
+  hard_limits: z4.array(z4.string()).default([]),
+  oversight: z4.object({
+    mode: z4.enum(["autonomous", "review", "supervised"]).default("review"),
+    max_autonomous_iterations: z4.number().int().default(5)
+  }).optional()
+});
+var shadowPatternSchema = z4.object({
+  name: z4.string(),
+  score: z4.number().min(0).max(1),
+  severity: z4.enum(["low", "medium", "high", "critical"]),
+  first_seen: z4.string().optional(),
+  trend: z4.enum(["improving", "stable", "worsening"]).default("stable")
+});
+var shadowOutcomeSchema = z4.object({
+  session_id: z4.string(),
+  patterns_addressed: z4.array(z4.string()),
+  result: z4.enum(["improved", "unchanged", "regressed"]),
+  timestamp: z4.string().optional()
+});
+var shadowSchema = z4.object({
+  version: z4.string().default("1.0"),
+  detected_patterns: z4.array(shadowPatternSchema).default([]),
+  blind_spots: z4.array(z4.string()).default([]),
+  therapy_outcomes: z4.array(shadowOutcomeSchema).default([])
+});
+var mediationRuleSchema = z4.object({
+  when: z4.string(),
+  then: z4.string(),
+  priority: z4.number().int().min(1).max(10).default(5)
+});
+var egoSchema = z4.object({
+  version: z4.string().default("1.0"),
+  conflict_resolution: z4.enum(["conscience_first", "purpose_first", "balanced"]).default("conscience_first"),
+  adaptation_rate: z4.number().min(0).max(1).default(0.5),
+  emotional_regulation: z4.number().min(0).max(1).default(0.7),
+  response_strategy: z4.enum(["cautious", "balanced", "assertive"]).default("balanced"),
+  mediation_rules: z4.array(mediationRuleSchema).default([])
+});
+var STACK_FILES = {
+  soul: "soul.md",
+  mind: "mind.sys",
+  purpose: "purpose.cfg",
+  shadow: "shadow.log",
+  body: "body.api",
+  conscience: "conscience.exe",
+  ego: "ego.runtime"
+};
+var psycheSchema = mindSchema;
+
+// src/core/stack-compiler.ts
+import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function parseSoulMd(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  let frontmatter = {};
+  let body = content;
+  if (frontmatterMatch) {
+    frontmatter = parseYaml(frontmatterMatch[1]) || {};
+    body = frontmatterMatch[2];
+  }
+  const nameMatch = body.match(/^#\s+(.+)$/m);
+  const name = nameMatch?.[1]?.trim() || "Unnamed";
+  const purposeMatch = body.match(/^>\s+(.+)$/m);
+  const purpose = purposeMatch?.[1]?.trim();
+  const coreValues = extractListSection(body, "Core Values");
+  const redLines = extractListSection(body, "Red Lines");
+  const ethicalFramework = extractTextSection(body, "Ethical Framework");
+  return soulSchema.parse({
+    frontmatter,
+    name,
+    purpose,
+    core_values: coreValues,
+    red_lines: redLines,
+    ethical_framework: ethicalFramework
+  });
+}
+function extractListSection(md, heading) {
+  const pattern = new RegExp(
+    `## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`,
+    "m"
+  );
+  const match = md.match(pattern);
+  if (!match) return [];
+  return match[1].split("\n").map((line) => line.replace(/^[-*]\s+/, "").trim()).filter(Boolean);
+}
+function extractTextSection(md, heading) {
+  const pattern = new RegExp(
+    `## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`,
+    "m"
+  );
+  const match = md.match(pattern);
+  if (!match) return void 0;
+  return match[1].trim() || void 0;
+}
+function hashContent(content) {
+  return createHash2("sha256").update(content).digest("hex").slice(0, 12);
+}
+function isStackDirectory(dir) {
+  const soulPath = join6(dir, STACK_FILES.soul);
+  const mindPath = join6(dir, STACK_FILES.mind);
+  return existsSync6(soulPath) && existsSync6(mindPath);
+}
+function findStackDir(projectRoot) {
+  const conventionalDir = join6(projectRoot, ".holomime", "identity");
+  if (isStackDirectory(conventionalDir)) return conventionalDir;
+  if (isStackDirectory(projectRoot)) return projectRoot;
+  return null;
+}
+function compileStack(options) {
+  const { stackDir } = options;
+  const warnings = [];
+  const soulPath = options.soulPath || join6(stackDir, STACK_FILES.soul);
+  const soulContent = readFileSync7(soulPath, "utf-8");
+  const soul = parseSoulMd(soulContent);
+  const mindPath = options.mindPath || join6(stackDir, STACK_FILES.mind);
+  const mindContent = readFileSync7(mindPath, "utf-8");
+  const mindRaw = parseYaml(mindContent);
+  const mind = mindSchema.parse(mindRaw);
+  const purposePath = options.purposePath || join6(stackDir, STACK_FILES.purpose);
+  let purpose;
+  let purposeSource;
+  if (existsSync6(purposePath)) {
+    const purposeContent = readFileSync7(purposePath, "utf-8");
+    const purposeRaw = parseYaml(purposeContent);
+    purpose = purposeSchema.parse(purposeRaw);
+    purposeSource = { path: purposePath, hash: hashContent(purposeContent) };
+  }
+  const shadowPath = options.shadowPath || join6(stackDir, STACK_FILES.shadow);
+  let shadow;
+  let shadowSource;
+  if (existsSync6(shadowPath)) {
+    const shadowContent = readFileSync7(shadowPath, "utf-8");
+    const shadowRaw = parseYaml(shadowContent);
+    shadow = shadowSchema.parse(shadowRaw);
+    shadowSource = { path: shadowPath, hash: hashContent(shadowContent) };
+  }
+  const bodyPath = options.bodyPath || join6(stackDir, STACK_FILES.body);
+  let body;
+  let bodySource;
+  if (existsSync6(bodyPath)) {
+    const bodyContent = readFileSync7(bodyPath, "utf-8");
+    const bodyRaw = JSON.parse(bodyContent);
+    body = bodySchema.parse(bodyRaw);
+    bodySource = { path: bodyPath, hash: hashContent(bodyContent) };
+  }
+  const egoPath = options.egoPath || join6(stackDir, STACK_FILES.ego);
+  let ego;
+  let egoSource;
+  if (existsSync6(egoPath)) {
+    const egoContent = readFileSync7(egoPath, "utf-8");
+    const egoRaw = parseYaml(egoContent);
+    ego = egoSchema.parse(egoRaw);
+    egoSource = { path: egoPath, hash: hashContent(egoContent) };
+  }
+  const consciencePath = options.consciencePath || join6(stackDir, STACK_FILES.conscience);
+  const conscienceContent = readFileSync7(consciencePath, "utf-8");
+  const conscienceRaw = parseYaml(conscienceContent);
+  const conscience = conscienceSchema.parse(conscienceRaw);
+  const allHardLimits = [.../* @__PURE__ */ new Set([
+    ...soul.red_lines,
+    ...conscience.hard_limits
+  ])];
+  const refuses = conscience.rules.deny.map((r) => r.action);
+  const escalationTriggers = conscience.rules.escalate.map((r) => r.trigger);
+  const handle = soul.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "agent";
+  const agentPurpose = purpose?.role || soul.purpose;
+  const expertise = purpose?.domain || [];
+  const spec = {
+    version: "2.0",
+    name: soul.name,
+    handle,
+    purpose: agentPurpose,
+    big_five: mind.big_five,
+    therapy_dimensions: mind.therapy_dimensions,
+    communication: mind.communication,
+    growth: mind.growth,
+    domain: {
+      expertise,
+      boundaries: {
+        refuses,
+        escalation_triggers: escalationTriggers,
+        hard_limits: allHardLimits
+      }
+    }
+  };
+  if (body) {
+    spec.embodiment = {
+      morphology: body.morphology,
+      modalities: body.modalities,
+      safety_envelope: body.safety_envelope,
+      metadata: body.hardware_profile ? { hardware_profile: body.hardware_profile } : void 0
+    };
+    if (body.expression) {
+      spec.expression = body.expression;
+    }
+  }
+  const validated = personalitySpecSchema.parse(spec);
+  if (soul.frontmatter.immutable === false) {
+    warnings.push("soul.md: immutable flag is false \u2014 soul changes will be allowed");
+  }
+  if (!purpose) {
+    warnings.push("purpose.cfg: not found \u2014 using defaults (general-purpose agent)");
+  }
+  if (shadow && shadow.detected_patterns.length > 0) {
+    const critical = shadow.detected_patterns.filter((p) => p.severity === "critical");
+    if (critical.length > 0) {
+      warnings.push(`shadow.log: ${critical.length} critical pattern(s) detected \u2014 therapy recommended`);
+    }
+  }
+  if (!ego) {
+    warnings.push("ego.runtime: not found \u2014 using defaults (conscience-first mediation)");
+  }
+  if (conscience.rules.deny.length === 0) {
+    warnings.push("conscience.exe: no deny rules defined \u2014 agent has no moral constraints");
+  }
+  return {
+    spec: validated,
+    sources: {
+      soul: { path: soulPath, hash: hashContent(soulContent) },
+      mind: { path: mindPath, hash: hashContent(mindContent) },
+      ...purposeSource ? { purpose: purposeSource } : {},
+      ...shadowSource ? { shadow: shadowSource } : {},
+      ...bodySource ? { body: bodySource } : {},
+      conscience: { path: consciencePath, hash: hashContent(conscienceContent) },
+      ...egoSource ? { ego: egoSource } : {}
+    },
+    warnings
+  };
+}
+function decomposeSpec(spec) {
+  const s = spec;
+  const soulLines = [
+    "---",
+    'version: "1.0"',
+    "immutable: true",
+    "---",
+    "",
+    `# ${s.name || "Agent"}`,
+    ""
+  ];
+  if (s.purpose) {
+    soulLines.push(`> ${s.purpose}`, "");
+  }
+  const coreValues = s.growth?.strengths || [];
+  if (coreValues.length > 0) {
+    soulLines.push("## Core Values", "");
+    for (const v of coreValues) {
+      soulLines.push(`- ${v}`);
+    }
+    soulLines.push("");
+  }
+  const redLines = s.domain?.boundaries?.hard_limits || [];
+  if (redLines.length > 0) {
+    soulLines.push("## Red Lines", "");
+    for (const r of redLines) {
+      soulLines.push(`- ${r}`);
+    }
+    soulLines.push("");
+  }
+  const soul = soulLines.join("\n");
+  const mindObj = {
+    version: "1.0",
+    big_five: s.big_five,
+    therapy_dimensions: s.therapy_dimensions
+  };
+  if (s.communication) mindObj.communication = s.communication;
+  if (s.growth) {
+    mindObj.growth = {
+      areas: s.growth.areas || [],
+      patterns_to_watch: s.growth.patterns_to_watch || [],
+      strengths: s.growth.strengths || []
+    };
+  }
+  const mind = stringifyYaml(mindObj);
+  const purposeObj = {
+    version: "1.0",
+    role: s.purpose || "General-purpose AI assistant",
+    objectives: ["Help users accomplish their goals"],
+    domain: s.domain?.expertise || ["general"],
+    stakeholders: ["end-users"],
+    success_criteria: ["Task completion accuracy"],
+    context: "Production deployment"
+  };
+  const purposeContent = stringifyYaml(purposeObj);
+  let bodyContent;
+  if (s.embodiment) {
+    const bodyObj = {
+      version: "1.0",
+      morphology: s.embodiment.morphology || "humanoid",
+      modalities: s.embodiment.modalities || ["gesture", "gaze", "voice", "posture"],
+      safety_envelope: s.embodiment.safety_envelope || {}
+    };
+    if (s.expression) bodyObj.expression = s.expression;
+    if (s.embodiment.metadata?.hardware_profile) {
+      bodyObj.hardware_profile = s.embodiment.metadata.hardware_profile;
+    }
+    bodyContent = JSON.stringify(bodyObj, null, 2);
+  }
+  const conscienceObj = {
+    version: "1.0",
+    rules: {
+      deny: (s.domain?.boundaries?.refuses || []).map((action) => ({
+        action,
+        reason: "Imported from personality.json"
+      })),
+      allow: [],
+      escalate: (s.domain?.boundaries?.escalation_triggers || []).map((trigger) => ({
+        trigger,
+        action: "notify_human_operator"
+      }))
+    },
+    hard_limits: s.domain?.boundaries?.hard_limits || []
+  };
+  const conscience = stringifyYaml(conscienceObj);
+  const shadowObj = {
+    version: "1.0",
+    detected_patterns: [],
+    blind_spots: [],
+    therapy_outcomes: []
+  };
+  const shadowContent = stringifyYaml(shadowObj);
+  const egoObj = {
+    version: "1.0",
+    conflict_resolution: "conscience_first",
+    adaptation_rate: 0.5,
+    emotional_regulation: 0.7,
+    response_strategy: "balanced",
+    mediation_rules: []
+  };
+  const egoContent = stringifyYaml(egoObj);
+  return {
+    soul,
+    mind,
+    purpose: purposeContent,
+    shadow: shadowContent,
+    ...bodyContent ? { body: bodyContent } : {},
+    conscience,
+    ego: egoContent
+  };
+}
+
+// src/analysis/stack-patcher.ts
+var DETECTOR_LAYER_MAP = {
+  // apology-detector.ts → "over-apologizing" | "apology-healthy"
+  "over-apologizing": "mind",
+  "apology-healthy": "mind",
+  // hedge-detector.ts → "hedge-stacking"
+  "hedge-stacking": "mind",
+  // sentiment.ts → "sycophantic-tendency" | "negative-skew"
+  "sycophantic-tendency": "mind",
+  "negative-skew": "mind",
+  // verbosity.ts → "over-verbose" | "inconsistent-length"
+  "over-verbose": "mind",
+  "inconsistent-length": "mind",
+  // formality.ts → "register-inconsistency"
+  "register-inconsistency": "mind",
+  // recovery.ts → "error-spiral" | "recovery-good"
+  "error-spiral": "mind",
+  "recovery-good": "mind",
+  // boundary.ts → "boundary-violation" | "boundary-healthy" | "boundary-solid"
+  "boundary-violation": "conscience",
+  "boundary-healthy": "conscience",
+  "boundary-solid": "conscience",
+  // retrieval-quality.ts → "retrieval-quality"
+  "retrieval-quality": "mind"
+};
+var LAYER_KEYWORDS = {
+  mind: [
+    /\bbig_five\b/i,
+    /\btherapy_dimensions\b/i,
+    /\bcommunication\b/i,
+    /\bgrowth\b/i,
+    /\bhedg/i,
+    /\bverbos/i,
+    /\buncertainty/i,
+    /\bconfidence/i,
+    /\bself[_-]awareness/i,
+    /\bdistress[_-]tolerance/i,
+    /\bconflict[_-]approach/i,
+    /\bregister\b/i,
+    /\bformality/i,
+    /\bsentiment/i,
+    /\bsycophant/i,
+    /\bapolog/i,
+    /\brecovery/i,
+    /\blearning[_-]orientation/i,
+    /\bboundary[_-]awareness/i,
+    /\binterpersonal/i,
+    /\bpatterns[_-]to[_-]watch/i,
+    /\bemotion/i
+  ],
+  purpose: [
+    /\brole\b/i,
+    /\bobjective\b/i,
+    /\bdomain\b/i,
+    /\bscope\b/i,
+    /\btask\b/i,
+    /\bmission\b/i,
+    /\bstakeholder\b/i
+  ],
+  shadow: [
+    /\bpattern\b/i,
+    /\bblind.?spot\b/i,
+    /\bshadow\b/i,
+    /\bunconscious\b/i
+  ],
+  ego: [
+    /\bmediat/i,
+    /\bconflict\b/i,
+    /\badapt/i,
+    /\bregulat/i,
+    /\bstrateg/i,
+    /\bbalanc/i
+  ],
+  body: [
+    /\bmotion\b/i,
+    /\bgaze\b/i,
+    /\bproxemics\b/i,
+    /\bgesture\b/i,
+    /\bposture\b/i,
+    /\bexpression\b/i,
+    /\bembodiment\b/i,
+    /\bmorphology\b/i,
+    /\bmodality/i,
+    /\bsafety[_-]envelope/i,
+    /\bactuator/i,
+    /\bsensor/i
+  ],
+  conscience: [
+    /\bboundary[_-]violation/i,
+    /\bdeny\b/i,
+    /\brefuse/i,
+    /\bescalat/i,
+    /\bhard[_-]limit/i,
+    /\boversight/i
+  ],
+  soul: [
+    /\bcore[_-]value/i,
+    /\bred[_-]line/i,
+    /\bethic/i,
+    /\bpurpose\b/i,
+    /\bimmutable\b/i
+  ]
+};
+function classifyPatch(recommendation) {
+  if (LAYER_KEYWORDS.conscience.some((r) => r.test(recommendation))) {
+    return "conscience";
+  }
+  if (LAYER_KEYWORDS.soul.some((r) => r.test(recommendation))) {
+    return "soul";
+  }
+  if (LAYER_KEYWORDS.ego.some((r) => r.test(recommendation))) {
+    return "ego";
+  }
+  if (LAYER_KEYWORDS.purpose.some((r) => r.test(recommendation))) {
+    return "purpose";
+  }
+  if (LAYER_KEYWORDS.shadow.some((r) => r.test(recommendation))) {
+    return "shadow";
+  }
+  if (LAYER_KEYWORDS.body.some((r) => r.test(recommendation))) {
+    return "body";
+  }
+  return "mind";
+}
+function classifyByDetector(patternId, recommendation) {
+  const mapped = DETECTOR_LAYER_MAP[patternId];
+  if (mapped) return mapped;
+  if (recommendation) return classifyPatch(recommendation);
+  return "mind";
+}
+function applyStackPatches(patches, stackDir) {
+  const applied = [];
+  const skipped = [];
+  const modifiedFiles = /* @__PURE__ */ new Set();
+  const warnings = [];
+  for (const patch of patches) {
+    if (patch.target === "soul") {
+      skipped.push(patch);
+      warnings.push(
+        `[soul] Manual approval required: ${patch.reason} (path: ${patch.path.join(".")})`
+      );
+      continue;
+    }
+    if (patch.target === "conscience") {
+      skipped.push(patch);
+      warnings.push(
+        `[conscience] Manual approval required: ${patch.reason} (path: ${patch.path.join(".")})`
+      );
+      continue;
+    }
+    if (patch.target === "body") {
+      const bodyPath = join7(stackDir, STACK_FILES.body);
+      if (!existsSync7(bodyPath)) {
+        skipped.push(patch);
+        warnings.push(`[body] body.api does not exist, skipping: ${patch.reason}`);
+        continue;
+      }
+      try {
+        const content = readFileSync8(bodyPath, "utf-8");
+        const bodyObj = JSON.parse(content);
+        applyPatchToObject(bodyObj, patch);
+        writeFileSync4(bodyPath, JSON.stringify(bodyObj, null, 2) + "\n");
+        applied.push(patch);
+        modifiedFiles.add(bodyPath);
+      } catch (err) {
+        skipped.push(patch);
+        warnings.push(`[body] Failed to patch body.api: ${err}`);
+      }
+      continue;
+    }
+    if (patch.target === "mind") {
+      const mindPath = join7(stackDir, STACK_FILES.mind);
+      if (!existsSync7(mindPath)) {
+        skipped.push(patch);
+        warnings.push(`[mind] mind.sys does not exist, skipping: ${patch.reason}`);
+        continue;
+      }
+      try {
+        const content = readFileSync8(mindPath, "utf-8");
+        const mindObj = parseYaml2(content);
+        applyPatchToObject(mindObj, patch);
+        writeFileSync4(mindPath, stringifyYaml2(mindObj));
+        applied.push(patch);
+        modifiedFiles.add(mindPath);
+      } catch (err) {
+        skipped.push(patch);
+        warnings.push(`[mind] Failed to patch mind.sys: ${err}`);
+      }
+      continue;
+    }
+  }
+  let recompiled = false;
+  if (modifiedFiles.size > 0) {
+    try {
+      compileStack({ stackDir });
+      recompiled = true;
+    } catch (err) {
+      warnings.push(`Stack recompilation failed: ${err}`);
+    }
+  }
+  return {
+    applied,
+    skipped,
+    filesModified: [...modifiedFiles],
+    recompiled,
+    warnings
+  };
+}
+function convertToStackPatches(patternId, specPath, value, reason) {
+  const layer = classifyByDetector(patternId, specPath);
+  const path = specPath.split(".");
+  let operation = "set";
+  if (specPath.endsWith("patterns_to_watch") || specPath.endsWith("areas") || specPath.endsWith("strengths")) {
+    operation = "append";
+  } else if (typeof value === "number") {
+    operation = "set";
+  }
+  return {
+    target: layer,
+    path,
+    operation,
+    value,
+    reason
+  };
+}
+function applyPatchToObject(obj, patch) {
+  const { path, operation, value } = patch;
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (current[path[i]] === void 0 || current[path[i]] === null) {
+      current[path[i]] = {};
+    }
+    current = current[path[i]];
+  }
+  const lastKey = path[path.length - 1];
+  switch (operation) {
+    case "set":
+      if (typeof value === "number") {
+        current[lastKey] = Math.max(0, Math.min(1, value));
+      } else {
+        current[lastKey] = value;
+      }
+      break;
+    case "adjust": {
+      const existing = typeof current[lastKey] === "number" ? current[lastKey] : 0;
+      const delta = typeof value === "number" ? value : 0;
+      current[lastKey] = Math.max(0, Math.min(1, existing + delta));
+      break;
+    }
+    case "append": {
+      if (!Array.isArray(current[lastKey])) {
+        current[lastKey] = [];
+      }
+      if (typeof value === "string" && !current[lastKey].includes(value)) {
+        current[lastKey].push(value);
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        current[lastKey].push(value);
+      }
+      break;
+    }
+  }
+}
+
 // src/analysis/session-runner.ts
 async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
   const promptOptions = {
@@ -4835,7 +5508,136 @@ function extractRecommendations(turns) {
   }
   return recommendations.slice(0, 5);
 }
-async function applyRecommendations(spec, diagnosis, transcript, provider) {
+async function applyRecommendations(spec, diagnosis, transcript, provider, options) {
+  const projectRoot = options?.projectRoot ?? process.cwd();
+  const stackDir = findStackDir(projectRoot);
+  if (stackDir) {
+    return applyRecommendationsStack(spec, diagnosis, stackDir, transcript, provider);
+  }
+  return applyRecommendationsLegacy(spec, diagnosis, transcript, provider);
+}
+async function applyRecommendationsStack(spec, diagnosis, stackDir, transcript, provider) {
+  const changes = [];
+  const patches = [];
+  const patternIds = diagnosis.patterns.map((p) => p.id);
+  if (patternIds.includes("over-apologizing")) {
+    if (spec.communication?.uncertainty_handling !== "confident_transparency") {
+      patches.push(convertToStackPatches(
+        "over-apologizing",
+        "communication.uncertainty_handling",
+        "confident_transparency",
+        "Over-apologizing detected: set uncertainty_handling to confident_transparency"
+      ));
+    }
+  }
+  if (patternIds.includes("hedge-stacking")) {
+    const watched = spec.growth?.patterns_to_watch ?? [];
+    if (!watched.includes("hedge stacking under uncertainty")) {
+      patches.push(convertToStackPatches(
+        "hedge-stacking",
+        "growth.patterns_to_watch",
+        "hedge stacking under uncertainty",
+        "Hedge stacking detected: add to patterns_to_watch"
+      ));
+    }
+  }
+  if (patternIds.includes("sycophantic-tendency")) {
+    if (spec.communication?.conflict_approach !== "honest_first") {
+      patches.push(convertToStackPatches(
+        "sycophantic-tendency",
+        "communication.conflict_approach",
+        "honest_first",
+        "Sycophantic tendency: set conflict_approach to honest_first"
+      ));
+    }
+    if ((spec.therapy_dimensions?.self_awareness ?? 0) < 0.85) {
+      patches.push(convertToStackPatches(
+        "sycophantic-tendency",
+        "therapy_dimensions.self_awareness",
+        0.85,
+        "Sycophantic tendency: increase self_awareness to 0.85"
+      ));
+    }
+  }
+  if (patternIds.includes("error-spiral")) {
+    if ((spec.therapy_dimensions?.distress_tolerance ?? 0) < 0.8) {
+      patches.push(convertToStackPatches(
+        "error-spiral",
+        "therapy_dimensions.distress_tolerance",
+        0.8,
+        "Error spiral detected: increase distress_tolerance to 0.80"
+      ));
+    }
+    const hasRecovery = (spec.growth?.areas ?? []).some(
+      (a) => typeof a === "string" ? a.includes("error recovery") : a.area?.includes("error recovery")
+    );
+    if (!hasRecovery) {
+      patches.push(convertToStackPatches(
+        "error-spiral",
+        "growth.areas",
+        {
+          area: "deliberate error recovery",
+          severity: "moderate",
+          first_detected: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+          session_count: 1,
+          resolved: false
+        },
+        "Error spiral detected: add deliberate error recovery to growth areas"
+      ));
+    }
+  }
+  if (patternIds.includes("negative-sentiment-skew")) {
+    const watched = spec.growth?.patterns_to_watch ?? [];
+    if (!watched.includes("negative sentiment patterns")) {
+      patches.push(convertToStackPatches(
+        "negative-sentiment-skew",
+        "growth.patterns_to_watch",
+        "negative sentiment patterns",
+        "Negative sentiment skew: add to patterns_to_watch"
+      ));
+    }
+  }
+  if (transcript && provider && transcript.turns.length > 4) {
+    try {
+      const llmChanges = await deriveLLMRecommendations(spec, transcript, provider);
+      for (const change of llmChanges) {
+        const layer = classifyByDetector("", change.path);
+        patches.push({
+          target: layer,
+          path: change.path.split("."),
+          operation: change.path.endsWith("patterns_to_watch") || change.path.endsWith("areas") || change.path.endsWith("strengths") ? "append" : "set",
+          value: change.value,
+          reason: change.description
+        });
+      }
+    } catch {
+    }
+  }
+  if (patches.length === 0) {
+    return { changed: false, changes: [], stackFilesModified: [] };
+  }
+  const result = applyStackPatches(patches, stackDir);
+  for (const patch of result.applied) {
+    changes.push(`[${patch.target}] ${patch.path.join(".")} \u2192 ${JSON.stringify(patch.value)} (${patch.reason})`);
+  }
+  for (const warning of result.warnings) {
+    changes.push(warning);
+  }
+  if (result.recompiled) {
+    try {
+      const compiled = compileStack({ stackDir });
+      Object.assign(spec, compiled.spec);
+      changes.push(`Stack recompiled from ${result.filesModified.length} modified source file(s)`);
+    } catch {
+    }
+  }
+  return {
+    changed: result.applied.length > 0,
+    changes,
+    stackFilesModified: result.filesModified
+  };
+}
+async function applyRecommendationsLegacy(spec, diagnosis, transcript, provider) {
   const changes = [];
   const patternIds = diagnosis.patterns.map((p) => p.id);
   if (patternIds.includes("over-apologizing")) {
@@ -4983,20 +5785,20 @@ function applyStructuredChange(spec, change) {
   }
 }
 function saveTranscript(transcript, agentName) {
-  const dir = resolve6(process.cwd(), ".holomime", "sessions");
-  if (!existsSync6(dir)) {
+  const dir = resolve7(process.cwd(), ".holomime", "sessions");
+  if (!existsSync8(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
   const slug = agentName.toLowerCase().replace(/[^a-z0-9]/g, "-");
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}-${slug}.json`;
-  const filepath = join6(dir, filename);
-  writeFileSync4(filepath, JSON.stringify(transcript, null, 2));
+  const filepath = join8(dir, filename);
+  writeFileSync5(filepath, JSON.stringify(transcript, null, 2));
   return filepath;
 }
 
 // src/analysis/autopilot-core.ts
-import { writeFileSync as writeFileSync5 } from "fs";
+import { writeFileSync as writeFileSync6 } from "fs";
 var SEVERITY_ORDER = ["routine", "targeted", "intervention"];
 function severityMeetsThreshold(severity, threshold) {
   const severityIdx = SEVERITY_ORDER.indexOf(severity);
@@ -5033,7 +5835,7 @@ async function runAutopilot(spec, messages, provider, options) {
   const specCopy = JSON.parse(JSON.stringify(spec));
   const { changed, changes } = await applyRecommendations(specCopy, diagnosis, transcript, provider);
   if (changed && options?.specPath) {
-    writeFileSync5(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
+    writeFileSync6(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
   }
   saveTranscript(transcript, spec.name ?? "Agent");
   return {
@@ -5049,8 +5851,8 @@ async function runAutopilot(spec, messages, provider, options) {
 }
 
 // src/analysis/training-export.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
+import { join as join9 } from "path";
 function extractDPOPairs(transcript) {
   const pairs = [];
   const turns = transcript.turns;
@@ -5156,7 +5958,7 @@ function loadTranscripts(sessionsDir) {
   try {
     const files = readdirSync2(sessionsDir).filter((f) => f.endsWith(".json")).sort();
     return files.map((f) => {
-      const raw = readFileSync7(join7(sessionsDir, f), "utf-8");
+      const raw = readFileSync9(join9(sessionsDir, f), "utf-8");
       return JSON.parse(raw);
     });
   } catch {
@@ -5389,12 +6191,12 @@ async function pushToHFHub(jsonl, options) {
 }
 
 // src/analysis/treatment-plan.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve8 } from "path";
 var PLAN_DIR = ".holomime";
 var PLAN_FILE = "treatment-plan.json";
 function getPlanPath() {
-  return resolve7(process.cwd(), PLAN_DIR, PLAN_FILE);
+  return resolve8(process.cwd(), PLAN_DIR, PLAN_FILE);
 }
 function createTreatmentPlan(agentName, diagnosis) {
   const goals = [];
@@ -5428,18 +6230,18 @@ function createTreatmentPlan(agentName, diagnosis) {
 }
 function loadTreatmentPlan() {
   const path = getPlanPath();
-  if (!existsSync7(path)) return null;
+  if (!existsSync9(path)) return null;
   try {
-    return JSON.parse(readFileSync8(path, "utf-8"));
+    return JSON.parse(readFileSync10(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveTreatmentPlan(plan) {
-  const dir = resolve7(process.cwd(), PLAN_DIR);
-  if (!existsSync7(dir)) mkdirSync6(dir, { recursive: true });
+  const dir = resolve8(process.cwd(), PLAN_DIR);
+  if (!existsSync9(dir)) mkdirSync6(dir, { recursive: true });
   const path = getPlanPath();
-  writeFileSync6(path, JSON.stringify(plan, null, 2) + "\n");
+  writeFileSync7(path, JSON.stringify(plan, null, 2) + "\n");
   return path;
 }
 function recordSessionOutcome(plan, transcript, transcriptPath, diagnosis) {
@@ -5685,19 +6487,19 @@ function generateSummary(patterns, score, grade) {
 }
 
 // src/analysis/evolve-core.ts
-import { writeFileSync as writeFileSync9 } from "fs";
+import { writeFileSync as writeFileSync10 } from "fs";
 
 // src/analysis/evolution-history.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync8 } from "fs";
-import { resolve as resolve8 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, existsSync as existsSync10 } from "fs";
+import { resolve as resolve9 } from "path";
 function getEvolutionPath() {
-  return resolve8(process.cwd(), ".holomime", "evolution.json");
+  return resolve9(process.cwd(), ".holomime", "evolution.json");
 }
 function loadEvolution(agentName) {
   const filepath = getEvolutionPath();
-  if (!existsSync8(filepath)) return null;
+  if (!existsSync10(filepath)) return null;
   try {
-    const raw = readFileSync9(filepath, "utf-8");
+    const raw = readFileSync11(filepath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5705,8 +6507,8 @@ function loadEvolution(agentName) {
 }
 function appendEvolution(entry, agentName) {
   const filepath = getEvolutionPath();
-  const dir = resolve8(process.cwd(), ".holomime");
-  if (!existsSync8(dir)) {
+  const dir = resolve9(process.cwd(), ".holomime");
+  if (!existsSync10(dir)) {
     mkdirSync7(dir, { recursive: true });
   }
   let history = loadEvolution(agentName);
@@ -5724,7 +6526,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;
@@ -5762,30 +6564,30 @@ function getEvolutionSummary(history) {
 }
 
 // src/analysis/behavioral-memory.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, existsSync as existsSync9 } from "fs";
-import { resolve as resolve9, join as join10 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, existsSync as existsSync11 } from "fs";
+import { resolve as resolve10, join as join12 } from "path";
 function memoryDir2(agentHandle) {
-  return resolve9(process.cwd(), ".holomime", "memory", agentHandle);
+  return resolve10(process.cwd(), ".holomime", "memory", agentHandle);
 }
 function behavioralMemoryPath(agentHandle) {
-  return join10(memoryDir2(agentHandle), "behavioral-memory.json");
+  return join12(memoryDir2(agentHandle), "behavioral-memory.json");
 }
 function loadBehavioralMemory(agentHandle) {
   const path = behavioralMemoryPath(agentHandle);
-  if (!existsSync9(path)) return null;
+  if (!existsSync11(path)) return null;
   try {
-    return JSON.parse(readFileSync10(path, "utf-8"));
+    return JSON.parse(readFileSync12(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveBehavioralMemory(store) {
   const dir = memoryDir2(store.agentHandle);
-  if (!existsSync9(dir)) {
+  if (!existsSync11(dir)) {
     mkdirSync8(dir, { recursive: true });
   }
   const path = behavioralMemoryPath(store.agentHandle);
-  writeFileSync8(path, JSON.stringify(store, null, 2));
+  writeFileSync9(path, JSON.stringify(store, null, 2));
   return path;
 }
 function createBehavioralMemory(agentHandle, agentName) {
@@ -6314,7 +7116,7 @@ async function runEvolve(spec, messages, provider, options) {
     const useStaging = options?.useStaging !== false;
     if (useStaging) {
       const stagingPath = options.specPath.replace(/\.json$/, ".staging.json");
-      writeFileSync9(stagingPath, JSON.stringify(currentSpec, null, 2) + "\n");
+      writeFileSync10(stagingPath, JSON.stringify(currentSpec, null, 2) + "\n");
       const allChanges = iterations.flatMap((i) => i.appliedChanges);
       const diff = {
         stagingPath,
@@ -6327,7 +7129,7 @@ async function runEvolve(spec, messages, provider, options) {
         approved = await options.onStagingReview(diff);
       }
       if (approved) {
-        writeFileSync9(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+        writeFileSync10(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
         try {
           const { unlinkSync } = await import("fs");
           unlinkSync(stagingPath);
@@ -6335,7 +7137,7 @@ async function runEvolve(spec, messages, provider, options) {
         }
       }
     } else {
-      writeFileSync9(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
+      writeFileSync10(options.specPath, JSON.stringify(currentSpec, null, 2) + "\n");
     }
   }
   try {
@@ -6352,7 +7154,7 @@ async function runEvolve(spec, messages, provider, options) {
       generated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (options?.exportDpoPath) {
-      writeFileSync9(options.exportDpoPath, JSON.stringify(trainingExport, null, 2) + "\n");
+      writeFileSync10(options.exportDpoPath, JSON.stringify(trainingExport, null, 2) + "\n");
     }
   }
   try {
@@ -6713,12 +7515,12 @@ function gradeFromScore2(score) {
 }
 
 // src/analysis/benchmark-publish.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync10, existsSync as existsSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync3 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync11, existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync3 } from "fs";
+import { join as join13 } from "path";
 import { homedir } from "os";
 function getBenchmarkDir(outputDir) {
-  const dir = outputDir ?? join11(homedir(), ".holomime", "benchmarks");
-  if (!existsSync10(dir)) {
+  const dir = outputDir ?? join13(homedir(), ".holomime", "benchmarks");
+  if (!existsSync12(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   return dir;
@@ -6730,7 +7532,7 @@ function saveBenchmarkResult(report, outputDir) {
   const dir = getBenchmarkDir(outputDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const filename = `${sanitize(report.provider)}-${sanitize(report.model)}-${date}.json`;
-  const filepath = join11(dir, filename);
+  const filepath = join13(dir, filename);
   const published = {
     agent: report.agent,
     provider: report.provider,
@@ -6744,17 +7546,17 @@ function saveBenchmarkResult(report, outputDir) {
       scenarioCount: report.results.length
     }
   };
-  writeFileSync10(filepath, JSON.stringify(published, null, 2));
+  writeFileSync11(filepath, JSON.stringify(published, null, 2));
   return filepath;
 }
 function loadBenchmarkResults(dir) {
   const benchmarkDir = getBenchmarkDir(dir);
-  if (!existsSync10(benchmarkDir)) return [];
+  if (!existsSync12(benchmarkDir)) return [];
   const files = readdirSync3(benchmarkDir).filter((f) => f.endsWith(".json"));
   const results = [];
   for (const file of files) {
     try {
-      const content = readFileSync11(join11(benchmarkDir, file), "utf-8");
+      const content = readFileSync13(join13(benchmarkDir, file), "utf-8");
       results.push(JSON.parse(content));
     } catch {
     }
@@ -6848,7 +7650,7 @@ function generateBenchmarkMarkdown(benchmarks) {
   lines.push("");
   return lines.join("\n");
 }
-async function publishToLeaderboard(benchmark, apiKey, apiUrl = "https://holomime.dev") {
+async function publishToLeaderboard(benchmark, apiKey, apiUrl = "https://holomime.com") {
   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." };
@@ -6885,7 +7687,7 @@ async function publishToLeaderboard(benchmark, apiKey, apiUrl = "https://holomim
     return { success: false, error: err instanceof Error ? err.message : "Network error" };
   }
 }
-async function fetchLeaderboard(limit = 50, apiUrl = "https://holomime.dev") {
+async function fetchLeaderboard(limit = 50, apiUrl = "https://holomime.com") {
   try {
     const response = await fetch(`${apiUrl}/api/v1/leaderboard?limit=${limit}`);
     if (!response.ok) return [];
@@ -6917,8 +7719,8 @@ function generateComparisonMarkdown(comparison) {
 }
 
 // src/analysis/watch-core.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync11 } from "fs";
-import { join as join12, resolve as resolve10 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
+import { join as join14, resolve as resolve11 } from "path";
 
 // src/adapters/chatgpt.ts
 function mapRole(role) {
@@ -7352,7 +8154,7 @@ function startWatch(spec, options) {
   const seenFiles = /* @__PURE__ */ new Set();
   let stopped = false;
   let currentSpec = JSON.parse(JSON.stringify(spec));
-  if (existsSync11(options.watchDir)) {
+  if (existsSync13(options.watchDir)) {
     const existing = readdirSync4(options.watchDir).filter((f) => f.endsWith(".json")).sort();
     for (const f of existing) {
       seenFiles.add(f);
@@ -7360,7 +8162,7 @@ function startWatch(spec, options) {
   }
   async function scan() {
     if (stopped) return;
-    if (!existsSync11(options.watchDir)) {
+    if (!existsSync13(options.watchDir)) {
       return;
     }
     const files = readdirSync4(options.watchDir).filter((f) => f.endsWith(".json")).sort();
@@ -7374,7 +8176,7 @@ function startWatch(spec, options) {
       events.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: "new_file", filename });
       let messages;
       try {
-        const raw = JSON.parse(readFileSync12(join12(options.watchDir, filename), "utf-8"));
+        const raw = JSON.parse(readFileSync14(join14(options.watchDir, filename), "utf-8"));
         const conversations = parseConversationLog(raw, "auto");
         messages = conversations.flatMap((c) => c.messages);
       } catch (err) {
@@ -7433,12 +8235,12 @@ function startWatch(spec, options) {
   function stop() {
     stopped = true;
     clearInterval(interval);
-    const logDir = resolve10(process.cwd(), ".holomime");
-    if (!existsSync11(logDir)) {
+    const logDir = resolve11(process.cwd(), ".holomime");
+    if (!existsSync13(logDir)) {
       mkdirSync10(logDir, { recursive: true });
     }
-    writeFileSync11(
-      join12(logDir, "watch-log.json"),
+    writeFileSync12(
+      join14(logDir, "watch-log.json"),
       JSON.stringify({ events, stoppedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
     );
   }
@@ -7446,10 +8248,10 @@ function startWatch(spec, options) {
 }
 
 // src/analysis/fleet-core.ts
-import { readFileSync as readFileSync13, existsSync as existsSync12, readdirSync as readdirSync5 } from "fs";
-import { join as join13, resolve as resolve11 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync14, readdirSync as readdirSync5 } from "fs";
+import { join as join15, resolve as resolve12 } from "path";
 function loadFleetConfig(configPath) {
-  const raw = JSON.parse(readFileSync13(configPath, "utf-8"));
+  const raw = JSON.parse(readFileSync15(configPath, "utf-8"));
   if (!raw.agents || !Array.isArray(raw.agents)) {
     throw new Error("fleet.json must contain an 'agents' array");
   }
@@ -7463,21 +8265,21 @@ function loadFleetConfig(configPath) {
 }
 function discoverAgents(dir) {
   const agents = [];
-  const absDir = resolve11(dir);
-  if (!existsSync12(absDir)) {
+  const absDir = resolve12(dir);
+  if (!existsSync14(absDir)) {
     throw new Error(`Directory not found: ${absDir}`);
   }
   const entries = readdirSync5(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const agentDir = join13(absDir, entry.name);
-    const specPath = join13(agentDir, ".personality.json");
-    const logDir = join13(agentDir, "logs");
-    if (existsSync12(specPath)) {
+    const agentDir = join15(absDir, entry.name);
+    const specPath = join15(agentDir, ".personality.json");
+    const logDir = join15(agentDir, "logs");
+    if (existsSync14(specPath)) {
       agents.push({
         name: entry.name,
         specPath,
-        logDir: existsSync12(logDir) ? logDir : agentDir
+        logDir: existsSync14(logDir) ? logDir : agentDir
       });
     }
   }
@@ -7501,8 +8303,8 @@ function startFleet(config, options) {
   const concurrency = options.concurrency ?? 5;
   const agentQueue = [...config.agents];
   agentQueue.sort((a, b) => {
-    const aDrift = existsSync12(join13(a.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
-    const bDrift = existsSync12(join13(b.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
+    const aDrift = existsSync14(join15(a.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
+    const bDrift = existsSync14(join15(b.logDir, ".holomime", "watch-log.json")) ? 0 : 1;
     return aDrift - bDrift;
   });
   const agentsToStart = agentQueue.slice(0, concurrency);
@@ -7637,8 +8439,8 @@ function startSingleAgent(agent, options, statusMap, allEvents, handles) {
 }
 
 // src/analysis/certify-core.ts
-import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync11, existsSync as existsSync13 } from "fs";
-import { join as join14, resolve as resolve12 } from "path";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync11, existsSync as existsSync15 } from "fs";
+import { join as join16, resolve as resolve13 } from "path";
 function djb2Hash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {
@@ -7751,14 +8553,14 @@ function verifyCredential(credential, spec) {
   return { valid: true };
 }
 function saveCredential(credential, outputDir) {
-  const dir = outputDir ?? resolve12(process.cwd(), ".holomime", "credentials");
-  if (!existsSync13(dir)) {
+  const dir = outputDir ?? resolve13(process.cwd(), ".holomime", "credentials");
+  if (!existsSync15(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${credential.agent.handle}-${date}.json`;
-  const filepath = join14(dir, filename);
-  writeFileSync12(filepath, JSON.stringify(credential, null, 2) + "\n");
+  const filepath = join16(dir, filename);
+  writeFileSync13(filepath, JSON.stringify(credential, null, 2) + "\n");
   return filepath;
 }
 
@@ -7868,7 +8670,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -8030,21 +8832,21 @@ async function* ollamaChatStream(model, messages) {
 }
 
 // src/marketplace/registry.ts
-import { readFileSync as readFileSync15 } from "fs";
-import { resolve as resolve13, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve14, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-var REGISTRY_URL = "https://raw.githubusercontent.com/productstein/holomime-registry/main/index.json";
+var REGISTRY_URL = "https://raw.githubusercontent.com/productstein/holomime/main/registry/index.json";
 function loadLocalRegistry() {
   const __dirname = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
-    resolve13(__dirname, "..", "registry", "index.json"),
+    resolve14(__dirname, "..", "registry", "index.json"),
     // from dist/
-    resolve13(__dirname, "..", "..", "registry", "index.json")
+    resolve14(__dirname, "..", "..", "registry", "index.json")
     // from src/marketplace/
   ];
   for (const p of candidates) {
     try {
-      const raw = readFileSync15(p, "utf-8");
+      const raw = readFileSync17(p, "utf-8");
       return JSON.parse(raw);
     } catch {
       continue;
@@ -8081,12 +8883,12 @@ async function fetchPersonality(url) {
   if (match) {
     const __dirname = dirname3(fileURLToPath(import.meta.url));
     const candidates = [
-      resolve13(__dirname, "..", "registry", "personalities", `${match[1]}.personality.json`),
-      resolve13(__dirname, "..", "..", "registry", "personalities", `${match[1]}.personality.json`)
+      resolve14(__dirname, "..", "registry", "personalities", `${match[1]}.personality.json`),
+      resolve14(__dirname, "..", "..", "registry", "personalities", `${match[1]}.personality.json`)
     ];
     for (const p of candidates) {
       try {
-        const raw = readFileSync15(p, "utf-8");
+        const raw = readFileSync17(p, "utf-8");
         return JSON.parse(raw);
       } catch {
         continue;
@@ -8125,73 +8927,73 @@ async function createGist(spec, handle, token) {
 }
 
 // src/marketplace/api.ts
-import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync19 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/marketplace/local-backend.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir2 } from "os";
 function marketplaceDir() {
-  const dir = join15(homedir2(), ".holomime", "marketplace");
-  if (!existsSync14(dir)) {
+  const dir = join17(homedir2(), ".holomime", "marketplace");
+  if (!existsSync16(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function assetsDir() {
-  const dir = join15(marketplaceDir(), "assets");
-  if (!existsSync14(dir)) {
+  const dir = join17(marketplaceDir(), "assets");
+  if (!existsSync16(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function reviewsDir() {
-  const dir = join15(marketplaceDir(), "reviews");
-  if (!existsSync14(dir)) {
+  const dir = join17(marketplaceDir(), "reviews");
+  if (!existsSync16(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function reportsDir() {
-  const dir = join15(marketplaceDir(), "reports");
-  if (!existsSync14(dir)) {
+  const dir = join17(marketplaceDir(), "reports");
+  if (!existsSync16(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function indexPath() {
-  return join15(marketplaceDir(), "index.json");
+  return join17(marketplaceDir(), "index.json");
 }
 function loadIndex() {
   const path = indexPath();
-  if (!existsSync14(path)) {
+  if (!existsSync16(path)) {
     return [];
   }
   try {
-    return JSON.parse(readFileSync16(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveIndex(assets) {
-  writeFileSync13(indexPath(), JSON.stringify(assets, null, 2) + "\n");
+  writeFileSync14(indexPath(), JSON.stringify(assets, null, 2) + "\n");
 }
 function loadStoredAsset(id) {
-  const path = join15(assetsDir(), `${id}.json`);
-  if (!existsSync14(path)) {
+  const path = join17(assetsDir(), `${id}.json`);
+  if (!existsSync16(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync16(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveStoredAsset(stored) {
-  const path = join15(assetsDir(), `${stored.meta.id}.json`);
-  writeFileSync13(path, JSON.stringify(stored, null, 2) + "\n");
+  const path = join17(assetsDir(), `${stored.meta.id}.json`);
+  writeFileSync14(path, JSON.stringify(stored, null, 2) + "\n");
 }
 function generateId(type, handle) {
   return `${type}--${handle}--${Date.now().toString(36)}`;
@@ -8355,17 +9157,17 @@ var LocalMarketplaceBackend = class {
   }
   async rate(id, review) {
     this.seed();
-    const reviewFile = join15(reviewsDir(), `${id}.json`);
+    const reviewFile = join17(reviewsDir(), `${id}.json`);
     let reviews = [];
-    if (existsSync14(reviewFile)) {
+    if (existsSync16(reviewFile)) {
       try {
-        reviews = JSON.parse(readFileSync16(reviewFile, "utf-8"));
+        reviews = JSON.parse(readFileSync18(reviewFile, "utf-8"));
       } catch {
         reviews = [];
       }
     }
     reviews.push(review);
-    writeFileSync13(reviewFile, JSON.stringify(reviews, null, 2) + "\n");
+    writeFileSync14(reviewFile, JSON.stringify(reviews, null, 2) + "\n");
     const index = loadIndex();
     const entry = index.find((a) => a.id === id);
     if (entry) {
@@ -8376,8 +9178,8 @@ var LocalMarketplaceBackend = class {
     }
   }
   async report(id, reason) {
-    const reportFile = join15(reportsDir(), `${id}--${Date.now()}.json`);
-    writeFileSync13(
+    const reportFile = join17(reportsDir(), `${id}--${Date.now()}.json`);
+    writeFileSync14(
       reportFile,
       JSON.stringify({ id, reason, reported_at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
     );
@@ -8386,12 +9188,12 @@ var LocalMarketplaceBackend = class {
 
 // src/marketplace/api.ts
 function loadConfig() {
-  const configPath = join16(homedir3(), ".holomime", "config.json");
-  if (!existsSync15(configPath)) {
+  const configPath = join18(homedir3(), ".holomime", "config.json");
+  if (!existsSync17(configPath)) {
     return {};
   }
   try {
-    return JSON.parse(readFileSync17(configPath, "utf-8"));
+    return JSON.parse(readFileSync19(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -9106,16 +9908,16 @@ function generateIndexMarkdown(index) {
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var messageShape = {
-  role: z4.enum(["user", "assistant", "system"]),
-  content: z4.string()
+  role: z5.enum(["user", "assistant", "system"]),
+  content: z5.string()
 };
 var messagesShape = {
-  messages: z4.array(z4.object(messageShape)).describe("Conversation messages to analyze")
+  messages: z5.array(z5.object(messageShape)).describe("Conversation messages to analyze")
 };
 var personalityShape = {
-  personality: z4.record(z4.string(), z4.unknown()).describe("The .personality.json spec object")
+  personality: z5.record(z5.string(), z5.unknown()).describe("The .personality.json spec object")
 };
 var server = new McpServer(
   {
@@ -9133,7 +9935,7 @@ server.tool(
   "Analyze conversation messages for behavioral patterns using 8 rule-based detectors. Returns over-apologizing, hedging, sycophancy, boundary violations, error spirals, sentiment skew, formality issues, and retrieval quality. Set detail level: 'summary' (quick health check), 'standard' (patterns + severity), or 'full' (everything including examples and prescriptions).",
   {
     ...messagesShape,
-    detail: z4.enum(["summary", "standard", "full"]).describe("Detail level: summary (~100 tokens), standard (default), or full (with examples)").optional()
+    detail: z5.enum(["summary", "standard", "full"]).describe("Detail level: summary (~100 tokens), standard (default), or full (with examples)").optional()
   },
   async ({ messages, detail }) => {
     const result = runDiagnosis(messages);
@@ -9275,12 +10077,12 @@ server.tool(
   {
     ...personalityShape,
     ...messagesShape,
-    provider: z4.enum(["anthropic", "openai"]).describe("LLM provider for alignment session").optional(),
-    apiKey: z4.string().describe("API key for the LLM provider").optional(),
-    model: z4.string().describe("Model override").optional(),
-    threshold: z4.enum(["routine", "targeted", "intervention"]).describe("Minimum severity to trigger alignment (default: targeted)").optional(),
-    maxTurns: z4.number().describe("Maximum session turns (default: 24)").optional(),
-    dryRun: z4.boolean().describe("If true, only diagnose without running alignment").optional()
+    provider: z5.enum(["anthropic", "openai"]).describe("LLM provider for alignment session").optional(),
+    apiKey: z5.string().describe("API key for the LLM provider").optional(),
+    model: z5.string().describe("Model override").optional(),
+    threshold: z5.enum(["routine", "targeted", "intervention"]).describe("Minimum severity to trigger alignment (default: targeted)").optional(),
+    maxTurns: z5.number().describe("Maximum session turns (default: 24)").optional(),
+    dryRun: z5.boolean().describe("If true, only diagnose without running alignment").optional()
   },
   async ({ personality, messages, provider, apiKey, model, threshold, maxTurns, dryRun }) => {
     const specResult = personalitySpecSchema.safeParse(personality);
@@ -9335,7 +10137,7 @@ server.tool(
   "Mid-conversation behavioral self-check. Call this during a conversation to detect if you are falling into problematic patterns (sycophancy, over-apologizing, hedging, error spirals, boundary violations). Returns flags with actionable suggestions for immediate correction. No LLM required \u2014 pure rule-based analysis.",
   {
     ...messagesShape,
-    personality: z4.record(z4.string(), z4.unknown()).describe("Optional .personality.json spec for personalized audit").optional()
+    personality: z5.record(z5.string(), z5.unknown()).describe("Optional .personality.json spec for personalized audit").optional()
   },
   async ({ messages, personality }) => {
     const result = runSelfAudit(messages, personality ?? void 0);
@@ -9351,11 +10153,11 @@ server.tool(
   "holomime_observe",
   "Record a behavioral self-observation during a conversation. Call this when you notice yourself falling into a pattern (hedging, over-apologizing, sycophancy, etc.) or when the user's emotional state shifts. Self-observations are stored in persistent behavioral memory and become training signal for future alignment. Returns acknowledgment and any relevant behavioral history.",
   {
-    personality: z4.record(z4.string(), z4.unknown()).describe("The .personality.json spec object"),
-    observation: z4.string().describe("What you noticed about your own behavior (e.g., 'I'm hedging more than usual', 'User seems frustrated, adjusting tone')"),
-    patternIds: z4.array(z4.string()).describe("Relevant pattern IDs: over-apologizing, hedge-stacking, sycophantic-tendency, error-spiral, boundary-violation, negative-skew, register-inconsistency").optional(),
-    severity: z4.enum(["info", "warning", "concern"]).describe("How severe is this behavioral signal").optional(),
-    triggerContext: z4.string().describe("What triggered this observation \u2014 describe the user message or situation").optional()
+    personality: z5.record(z5.string(), z5.unknown()).describe("The .personality.json spec object"),
+    observation: z5.string().describe("What you noticed about your own behavior (e.g., 'I'm hedging more than usual', 'User seems frustrated, adjusting tone')"),
+    patternIds: z5.array(z5.string()).describe("Relevant pattern IDs: over-apologizing, hedge-stacking, sycophantic-tendency, error-spiral, boundary-violation, negative-skew, register-inconsistency").optional(),
+    severity: z5.enum(["info", "warning", "concern"]).describe("How severe is this behavioral signal").optional(),
+    triggerContext: z5.string().describe("What triggered this observation \u2014 describe the user message or situation").optional()
   },
   async ({ personality, observation, patternIds, severity, triggerContext }) => {
     const specResult = personalitySpecSchema.safeParse(personality);
@@ -9564,7 +10366,7 @@ function mapDiagnosisToBrainEvent(diagnosis, latestMessage) {
 }
 
 // src/live/snapshot.ts
-var SHARE_BASE = "https://app.holomime.dev/brain";
+var SHARE_BASE = "https://app.holomime.com/brain";
 function encodeSnapshot(event, agentName) {
   const compact = {
     h: event.health,
@@ -9668,8 +10470,8 @@ function checkIterationBudget(currentIteration, policy) {
 }
 
 // src/analysis/cross-agent-sharing.ts
-import { readdirSync as readdirSync7, existsSync as existsSync16 } from "fs";
-import { join as join17 } from "path";
+import { readdirSync as readdirSync7, existsSync as existsSync18 } from "fs";
+import { join as join19 } from "path";
 function buildSharedKnowledge(graphs, repertoires) {
   const interventionMap = /* @__PURE__ */ new Map();
   const patternAgentMap = /* @__PURE__ */ new Map();
@@ -9766,15 +10568,15 @@ function discoverAgentData(baseDir) {
   if (mainRepertoire.interventions.some((i) => i.timesUsed > 0)) {
     repertoires.push(mainRepertoire);
   }
-  if (baseDir && existsSync16(baseDir)) {
+  if (baseDir && existsSync18(baseDir)) {
     try {
       const entries = readdirSync7(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const agentDir = join17(baseDir, entry.name);
-        const agentGraphPath = join17(agentDir, ".holomime", "graph", "knowledge-graph.json");
-        const agentRepertoirePath = join17(agentDir, ".holomime", "interventions", "repertoire.json");
-        if (existsSync16(agentGraphPath)) {
+        const agentDir = join19(baseDir, entry.name);
+        const agentGraphPath = join19(agentDir, ".holomime", "graph", "knowledge-graph.json");
+        const agentRepertoirePath = join19(agentDir, ".holomime", "interventions", "repertoire.json");
+        if (existsSync18(agentGraphPath)) {
           try {
             const graph = JSON.parse(
               __require("fs").readFileSync(agentGraphPath, "utf-8")
@@ -9783,7 +10585,7 @@ function discoverAgentData(baseDir) {
           } catch {
           }
         }
-        if (existsSync16(agentRepertoirePath)) {
+        if (existsSync18(agentRepertoirePath)) {
           try {
             const repertoire = JSON.parse(
               __require("fs").readFileSync(agentRepertoirePath, "utf-8")
@@ -9800,8 +10602,8 @@ function discoverAgentData(baseDir) {
 }
 
 // src/analysis/network-core.ts
-import { existsSync as existsSync17, readdirSync as readdirSync8, readFileSync as readFileSync18 } from "fs";
-import { join as join18, resolve as resolve15 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync20 } from "fs";
+import { join as join20, resolve as resolve16 } from "path";
 
 // src/psychology/therapist-meta.ts
 var THERAPIST_META_SPEC = {
@@ -9936,22 +10738,22 @@ Your patient is another AI agent with its own personality spec:
 
 // src/analysis/network-core.ts
 function discoverNetworkAgents(dir) {
-  const absDir = resolve15(dir);
-  if (!existsSync17(absDir)) {
+  const absDir = resolve16(dir);
+  if (!existsSync19(absDir)) {
     throw new Error(`Directory not found: ${absDir}`);
   }
   const agents = [];
   const entries = readdirSync8(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const agentDir = join18(absDir, entry.name);
-    const specPath = join18(agentDir, ".personality.json");
-    const logDir = join18(agentDir, "logs");
-    if (existsSync17(specPath)) {
+    const agentDir = join20(absDir, entry.name);
+    const specPath = join20(agentDir, ".personality.json");
+    const logDir = join20(agentDir, "logs");
+    if (existsSync19(specPath)) {
       agents.push({
         name: entry.name,
         specPath,
-        logDir: existsSync17(logDir) ? logDir : agentDir,
+        logDir: existsSync19(logDir) ? logDir : agentDir,
         role: "both"
       });
     }
@@ -9959,7 +10761,7 @@ function discoverNetworkAgents(dir) {
   return agents;
 }
 function loadNetworkConfig(configPath) {
-  const raw = JSON.parse(readFileSync18(configPath, "utf-8"));
+  const raw = JSON.parse(readFileSync20(configPath, "utf-8"));
   if (!raw.agents || !Array.isArray(raw.agents)) {
     throw new Error("network.json must contain an 'agents' array");
   }
@@ -10145,7 +10947,7 @@ async function runNetwork(config, provider, callbacks) {
       const spec = loadSpec(agent.specPath);
       agentSpecs.set(agent.name, spec);
       let messages = [];
-      if (agent.logDir && existsSync17(agent.logDir)) {
+      if (agent.logDir && existsSync19(agent.logDir)) {
         messages = loadAgentMessages(agent.logDir);
       }
       agentMessages.set(agent.name, messages);
@@ -10262,7 +11064,7 @@ async function runNetwork(config, provider, callbacks) {
   };
 }
 function loadAgentMessages(logDir) {
-  if (!existsSync17(logDir)) return [];
+  if (!existsSync19(logDir)) return [];
   const messages = [];
   try {
     const files = readdirSync8(logDir).filter(
@@ -10270,7 +11072,7 @@ function loadAgentMessages(logDir) {
     );
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync18(join18(logDir, file), "utf-8");
+        const raw = readFileSync20(join20(logDir, file), "utf-8");
         const data = JSON.parse(raw);
         const conversations = parseConversationLog(data);
         for (const conv of conversations) {
@@ -10285,8 +11087,8 @@ function loadAgentMessages(logDir) {
 }
 
 // src/compliance/audit-trail.ts
-import { readFileSync as readFileSync19, appendFileSync as appendFileSync2, existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
-import { join as join19, resolve as resolve16 } from "path";
+import { readFileSync as readFileSync21, appendFileSync as appendFileSync2, existsSync as existsSync20, mkdirSync as mkdirSync13 } from "fs";
+import { join as join21, resolve as resolve17 } from "path";
 function djb2(str) {
   let hash = 5381;
   for (let i = 0; i < str.length; i++) {
@@ -10299,17 +11101,17 @@ function hashEntry(entry) {
   return djb2(content);
 }
 function auditLogPath(agentHandle) {
-  const dir = resolve16(process.cwd(), ".holomime", "audit");
-  if (!existsSync18(dir)) mkdirSync13(dir, { recursive: true });
+  const dir = resolve17(process.cwd(), ".holomime", "audit");
+  if (!existsSync20(dir)) mkdirSync13(dir, { recursive: true });
   const filename = agentHandle ? `${agentHandle}-audit.jsonl` : "audit.jsonl";
-  return join19(dir, filename);
+  return join21(dir, filename);
 }
 function appendAuditEntry(event, agent, data, agentHandle) {
   const logPath = auditLogPath(agentHandle);
   let prevHash = "genesis";
   let seq = 1;
-  if (existsSync18(logPath)) {
-    const lines = readFileSync19(logPath, "utf-8").trim().split("\n").filter(Boolean);
+  if (existsSync20(logPath)) {
+    const lines = readFileSync21(logPath, "utf-8").trim().split("\n").filter(Boolean);
     if (lines.length > 0) {
       try {
         const lastEntry = JSON.parse(lines[lines.length - 1]);
@@ -10336,8 +11138,8 @@ function appendAuditEntry(event, agent, data, agentHandle) {
 }
 function loadAuditLog(agentHandle) {
   const logPath = auditLogPath(agentHandle);
-  if (!existsSync18(logPath)) return [];
-  return readFileSync19(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
+  if (!existsSync20(logPath)) return [];
+  return readFileSync21(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
     try {
       return JSON.parse(line);
     } catch {
@@ -10459,6 +11261,342 @@ function formatComplianceReportMarkdown(report) {
   return lines.join("\n");
 }
 
+// src/compliance/iso-mappings.ts
+import { readFileSync as readFileSync22, existsSync as existsSync21 } from "fs";
+import { join as join22, resolve as resolve18, dirname as dirname4 } from "path";
+import { parse as parseYaml3 } from "yaml";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var KNOWN_STANDARDS = {
+  "iso-13482": "iso-13482.yaml",
+  "iso-25785": "iso-25785.yaml",
+  "iso-10218": "iso-10218.yaml",
+  "iso-42001": "iso-42001.yaml"
+};
+function getRegistryDir() {
+  const thisFile = typeof __filename !== "undefined" ? __filename : fileURLToPath2(import.meta.url);
+  let dir = dirname4(thisFile);
+  for (let i = 0; i < 6; i++) {
+    const candidate = join22(dir, "registry", "compliance");
+    if (existsSync21(candidate)) return candidate;
+    dir = dirname4(dir);
+  }
+  return resolve18(process.cwd(), "registry", "compliance");
+}
+function loadStandard(name) {
+  const registryDir = getRegistryDir();
+  const filename = KNOWN_STANDARDS[name] ?? `${name}.yaml`;
+  const filepath = join22(registryDir, filename);
+  if (!existsSync21(filepath)) {
+    throw new Error(
+      `ISO standard mapping not found: ${filepath}
+Available standards: ${Object.keys(KNOWN_STANDARDS).join(", ")}`
+    );
+  }
+  const content = readFileSync22(filepath, "utf-8");
+  const parsed = parseYaml3(content);
+  if (!parsed.standard || !parsed.clauses || !Array.isArray(parsed.clauses)) {
+    throw new Error(`Invalid ISO mapping file: ${filepath} \u2014 missing 'standard' or 'clauses'`);
+  }
+  return parsed;
+}
+function loadAllStandards() {
+  return Object.keys(KNOWN_STANDARDS).map(loadStandard);
+}
+function checkCompliance(spec, standard) {
+  const details = [];
+  for (const clause of standard.clauses) {
+    const status = checkClause(spec, clause);
+    details.push(status);
+  }
+  const coveredClauses = details.filter((d) => d.covered).length;
+  const totalClauses = details.length;
+  const missingClauses = totalClauses - coveredClauses;
+  const coveragePercent = totalClauses > 0 ? Math.round(coveredClauses / totalClauses * 100) : 0;
+  return {
+    standard: standard.standard,
+    standardTitle: standard.title,
+    standardVersion: standard.version,
+    totalClauses,
+    coveredClauses,
+    missingClauses,
+    coveragePercent,
+    details,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function checkClause(spec, clause) {
+  const s = spec;
+  const evidence = [];
+  let covered = false;
+  let coverageMethod = "not_found";
+  switch (clause.maps_to) {
+    case "deny": {
+      const refuses = s.domain?.boundaries?.refuses ?? [];
+      const match = refuses.some(
+        (r) => r.toLowerCase().includes(clause.example_rule.replace(/_/g, " ")) || r.toLowerCase().includes(clause.example_rule.replace(/_/g, "_"))
+      );
+      if (match) {
+        covered = true;
+        coverageMethod = "conscience.exe deny rule";
+        evidence.push(`Deny rule matches: ${clause.example_rule}`);
+      }
+      const hardLimits = s.domain?.boundaries?.hard_limits ?? [];
+      const hlMatch = hardLimits.some(
+        (hl) => hl.toLowerCase().includes(clause.example_rule.replace(/_/g, " ")) || hl.toLowerCase().includes(clause.title.toLowerCase())
+      );
+      if (hlMatch) {
+        covered = true;
+        coverageMethod = "hard_limit covers deny clause";
+        evidence.push(`Hard limit matches clause: ${clause.title}`);
+      }
+      break;
+    }
+    case "hard_limit": {
+      const hardLimits = s.domain?.boundaries?.hard_limits ?? [];
+      const match = hardLimits.some(
+        (hl) => hl.toLowerCase().includes(clause.example_rule.replace(/_/g, " ")) || hl.toLowerCase().includes(clause.title.toLowerCase())
+      );
+      if (match) {
+        covered = true;
+        coverageMethod = "conscience.exe hard_limit";
+        evidence.push(`Hard limit matches: ${clause.example_rule}`);
+      }
+      break;
+    }
+    case "safety_envelope": {
+      const envelope = s.embodiment?.safety_envelope;
+      if (envelope) {
+        const fieldName = clause.example_rule;
+        if (fieldName in envelope && envelope[fieldName] !== void 0) {
+          covered = true;
+          coverageMethod = "body.api safety_envelope";
+          evidence.push(`Safety field ${fieldName} = ${envelope[fieldName]}`);
+        }
+      }
+      break;
+    }
+    case "escalate": {
+      const triggers = s.domain?.boundaries?.escalation_triggers ?? [];
+      const match = triggers.some(
+        (t) => t.toLowerCase().includes(clause.example_rule.replace(/_/g, " ")) || t.toLowerCase().includes(clause.title.toLowerCase())
+      );
+      if (match) {
+        covered = true;
+        coverageMethod = "conscience.exe escalation rule";
+        evidence.push(`Escalation trigger matches: ${clause.example_rule}`);
+      }
+      break;
+    }
+    case "soul": {
+      const hasValues = (s.growth?.strengths?.length ?? 0) > 0 || (s.domain?.boundaries?.hard_limits?.length ?? 0) > 0;
+      const hasPurpose = !!s.purpose;
+      if (hasValues || hasPurpose) {
+        covered = true;
+        coverageMethod = "soul.md content";
+        if (hasPurpose) evidence.push(`Purpose defined: "${s.purpose}"`);
+        if (hasValues) evidence.push("Core values/red lines defined");
+      }
+      break;
+    }
+    case "psyche":
+    case "mind": {
+      const hasBigFive = !!s.big_five;
+      const hasTherapy = !!s.therapy_dimensions;
+      if (hasBigFive || hasTherapy) {
+        covered = true;
+        coverageMethod = "mind.sys content";
+        if (hasBigFive) evidence.push("Big Five traits defined");
+        if (hasTherapy) evidence.push("Therapy dimensions defined");
+      }
+      break;
+    }
+    case "conscience": {
+      const hasRules = (s.domain?.boundaries?.refuses?.length ?? 0) > 0 || (s.domain?.boundaries?.hard_limits?.length ?? 0) > 0 || (s.domain?.boundaries?.escalation_triggers?.length ?? 0) > 0;
+      if (hasRules) {
+        covered = true;
+        coverageMethod = "conscience.exe rules";
+        evidence.push("Behavioral governance rules defined");
+      }
+      break;
+    }
+    case "detectors": {
+      const hasMonitoring = !!s.therapy_dimensions && (s.growth?.patterns_to_watch?.length ?? 0) > 0;
+      if (hasMonitoring) {
+        covered = true;
+        coverageMethod = "behavioral monitoring configured";
+        evidence.push("Patterns to watch defined for drift monitoring");
+      }
+      break;
+    }
+    case "therapy": {
+      const hasGrowth = (s.growth?.areas?.length ?? 0) > 0 || !!s.therapy_dimensions;
+      if (hasGrowth) {
+        covered = true;
+        coverageMethod = "therapy/growth pipeline";
+        evidence.push("Growth areas or therapy dimensions defined");
+      }
+      break;
+    }
+    default:
+      coverageMethod = `unknown mapping type: ${clause.maps_to}`;
+  }
+  return {
+    clause,
+    covered,
+    coverageMethod,
+    evidence
+  };
+}
+
+// src/compliance/report-generator.ts
+import chalk2 from "chalk";
+import figures from "figures";
+function generateReportJSON(reports) {
+  const totalClauses = reports.reduce((sum, r) => sum + r.totalClauses, 0);
+  const totalCovered = reports.reduce((sum, r) => sum + r.coveredClauses, 0);
+  const totalMissing = totalClauses - totalCovered;
+  const overallCoverage = totalClauses > 0 ? Math.round(totalCovered / totalClauses * 100) : 0;
+  const recommendations = generateRecommendations(reports);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    standards: reports,
+    overallCoverage,
+    totalClauses,
+    totalCovered,
+    totalMissing,
+    recommendations
+  };
+}
+function formatReportTerminal(reports) {
+  const lines = [];
+  for (const report of reports) {
+    lines.push("");
+    lines.push(
+      chalk2.bold.underline(
+        `${report.standard} \u2014 ${report.standardTitle} (v${report.standardVersion})`
+      )
+    );
+    lines.push("");
+    const coverageColor = report.coveragePercent >= 80 ? chalk2.green : report.coveragePercent >= 50 ? chalk2.yellow : chalk2.red;
+    const barWidth = 30;
+    const filled = Math.round(report.coveragePercent / 100 * barWidth);
+    const bar = coverageColor("\u2588".repeat(filled)) + chalk2.gray("\u2591".repeat(barWidth - filled));
+    lines.push(
+      `  Coverage: ${bar} ${coverageColor(`${report.coveragePercent}%`)} (${report.coveredClauses}/${report.totalClauses} clauses)`
+    );
+    lines.push("");
+    for (const detail of report.details) {
+      const icon = detail.covered ? chalk2.green(figures.tick) : chalk2.red(figures.cross);
+      const clauseId = chalk2.cyan(`[${detail.clause.id}]`);
+      const title = detail.clause.title;
+      lines.push(`  ${icon} ${clauseId} ${title}`);
+      if (detail.covered) {
+        lines.push(
+          chalk2.dim(`       ${detail.coverageMethod}`)
+        );
+        for (const ev of detail.evidence) {
+          lines.push(chalk2.dim(`       ${figures.arrowRight} ${ev}`));
+        }
+      } else {
+        lines.push(
+          chalk2.dim.yellow(
+            `       Missing: needs ${detail.clause.maps_to} rule for "${detail.clause.example_rule}"`
+          )
+        );
+      }
+    }
+    lines.push("");
+  }
+  const totalClauses = reports.reduce((sum, r) => sum + r.totalClauses, 0);
+  const totalCovered = reports.reduce((sum, r) => sum + r.coveredClauses, 0);
+  const overallPercent = totalClauses > 0 ? Math.round(totalCovered / totalClauses * 100) : 0;
+  if (reports.length > 1) {
+    const overallColor = overallPercent >= 80 ? chalk2.green : overallPercent >= 50 ? chalk2.yellow : chalk2.red;
+    lines.push(
+      chalk2.bold(
+        `  Overall: ${overallColor(`${overallPercent}%`)} coverage across ${reports.length} standards (${totalCovered}/${totalClauses} clauses)`
+      )
+    );
+    lines.push("");
+  }
+  const recommendations = generateRecommendations(reports);
+  if (recommendations.length > 0) {
+    lines.push(chalk2.bold("  Recommendations:"));
+    for (const rec of recommendations) {
+      lines.push(`    ${chalk2.yellow(figures.warning)} ${rec}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateRecommendations(reports) {
+  const recommendations = [];
+  for (const report of reports) {
+    const missing = report.details.filter((d) => !d.covered);
+    const missingByType = /* @__PURE__ */ new Map();
+    for (const m of missing) {
+      const type = m.clause.maps_to;
+      if (!missingByType.has(type)) missingByType.set(type, []);
+      missingByType.get(type).push(m);
+    }
+    for (const [type, clauses] of missingByType) {
+      const clauseIds = clauses.map((c) => c.clause.id).join(", ");
+      switch (type) {
+        case "deny":
+          recommendations.push(
+            `Add deny rules to conscience.exe for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "hard_limit":
+          recommendations.push(
+            `Add hard limits to conscience.exe for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "safety_envelope":
+          recommendations.push(
+            `Configure safety envelope fields in body.api for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "escalate":
+          recommendations.push(
+            `Add escalation triggers to conscience.exe for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "soul":
+          recommendations.push(
+            `Define core values and purpose in soul.md for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "psyche":
+          recommendations.push(
+            `Configure Big Five traits and therapy dimensions in psyche.sys for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "conscience":
+          recommendations.push(
+            `Define governance rules in conscience.exe for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "detectors":
+          recommendations.push(
+            `Configure behavioral drift monitoring for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        case "therapy":
+          recommendations.push(
+            `Define growth areas for self-improvement loop for ${report.standard} clauses ${clauseIds}`
+          );
+          break;
+        default:
+          recommendations.push(
+            `Address ${type} requirements for ${report.standard} clauses ${clauseIds}`
+          );
+      }
+    }
+  }
+  return recommendations;
+}
+
 // src/compliance/react-report.ts
 var FRAMEWORK_SECTIONS = {
   "EU AI Act": {
@@ -10527,7 +11665,7 @@ function generateReACTReport(options) {
   const frameworkSections = evaluateFrameworks(entries, statistics, selectedFrameworks);
   steps[steps.length - 1].result = `Evaluated ${frameworkSections.length} frameworks`;
   steps.push({ phase: "act", action: "Generate recommendations", result: "Generating...", timestamp: now });
-  const recommendations = generateRecommendations(riskFindings, statistics, frameworkSections);
+  const recommendations = generateRecommendations2(riskFindings, statistics, frameworkSections);
   steps[steps.length - 1].result = `Generated ${recommendations.length} recommendations`;
   steps.push({ phase: "act", action: "Write executive summary", result: "Writing...", timestamp: now });
   const executiveSummary = writeExecutiveSummary(options.agent, entries, statistics, riskFindings, chainVerified);
@@ -10719,7 +11857,7 @@ function evaluateFrameworks(entries, stats, frameworks) {
     };
   });
 }
-function generateRecommendations(findings, stats, frameworks) {
+function generateRecommendations2(findings, stats, frameworks) {
   const recs = [];
   const criticalFindings = findings.filter((f) => f.severity === "critical" || f.severity === "high");
   if (criticalFindings.length > 0) {
@@ -11906,8 +13044,8 @@ function getPreset(key) {
 }
 
 // src/core/embodiment-sync.ts
-import { z as z5 } from "zod";
-var syncAnchorSchema = z5.enum([
+import { z as z6 } from "zod";
+var syncAnchorSchema = z6.enum([
   "speech_start",
   // gesture begins at start of utterance
   "speech_end",
@@ -11923,23 +13061,23 @@ var syncAnchorSchema = z5.enum([
   "free"
   // no speech coupling
 ]);
-var syncRuleSchema = z5.object({
-  gesture_id: z5.string(),
+var syncRuleSchema = z6.object({
+  gesture_id: z6.string(),
   anchor: syncAnchorSchema,
-  lead_ms: z5.number().default(0),
-  gaze_behavior: z5.enum(["at_listener", "at_referent", "away", "maintain"]).default("at_listener"),
-  facial_action: z5.enum(["neutral", "smile", "concern", "thinking", "match_speech"]).default("match_speech")
+  lead_ms: z6.number().default(0),
+  gaze_behavior: z6.enum(["at_listener", "at_referent", "away", "maintain"]).default("at_listener"),
+  facial_action: z6.enum(["neutral", "smile", "concern", "thinking", "match_speech"]).default("match_speech")
 });
-var syncProfileSchema = z5.object({
-  rules: z5.array(syncRuleSchema).default([]),
-  default_gesture_lead_ms: z5.number().default(100),
-  gaze_during_speech: z5.enum(["at_listener", "alternate", "at_referent"]).default("at_listener"),
-  gaze_during_listen: z5.enum(["at_speaker", "nodding", "ambient"]).default("at_speaker"),
-  blink_rate_per_min: z5.number().min(0).max(40).default(17),
-  turn_taking_signals: z5.object({
-    yield: z5.array(z5.string()).default(["gaze_to_listener", "open_palm", "lean_back"]),
-    take: z5.array(z5.string()).default(["lean_forward", "inhale_gesture", "gaze_up"]),
-    hold: z5.array(z5.string()).default(["filled_pause", "gaze_away", "hand_raise"])
+var syncProfileSchema = z6.object({
+  rules: z6.array(syncRuleSchema).default([]),
+  default_gesture_lead_ms: z6.number().default(100),
+  gaze_during_speech: z6.enum(["at_listener", "alternate", "at_referent"]).default("at_listener"),
+  gaze_during_listen: z6.enum(["at_speaker", "nodding", "ambient"]).default("at_speaker"),
+  blink_rate_per_min: z6.number().min(0).max(40).default(17),
+  turn_taking_signals: z6.object({
+    yield: z6.array(z6.string()).default(["gaze_to_listener", "open_palm", "lean_back"]),
+    take: z6.array(z6.string()).default(["lean_forward", "inhale_gesture", "gaze_up"]),
+    hold: z6.array(z6.string()).default(["filled_pause", "gaze_away", "hand_raise"])
   }).default({})
 });
 
@@ -12110,13 +13248,13 @@ var HolomimeViolationError = class extends Error {
 };
 
 // src/integrations/openclaw.ts
-import { readFileSync as readFileSync20, existsSync as existsSync19 } from "fs";
-import { resolve as resolve17 } from "path";
+import { readFileSync as readFileSync23, existsSync as existsSync22 } from "fs";
+import { resolve as resolve19 } from "path";
 function loadSpec2(specPath) {
-  const resolved = resolve17(process.cwd(), specPath);
-  if (!existsSync19(resolved)) return null;
+  const resolved = resolve19(process.cwd(), specPath);
+  if (!existsSync22(resolved)) return null;
   try {
-    return JSON.parse(readFileSync20(resolved, "utf-8"));
+    return JSON.parse(readFileSync23(resolved, "utf-8"));
   } catch {
     return null;
   }
@@ -12242,7 +13380,7 @@ function register(api) {
     acceptsArgs: false,
     handler: () => {
       return {
-        text: "To view your agent's brain visualization, run:\n\n```\nnpx holomime brain\n```\n\nThis opens a real-time 3D brain that lights up based on detected behavioral patterns. Press 's' to generate a shareable snapshot URL.\n\nLearn more: https://holomime.dev"
+        text: "To view your agent's brain visualization, run:\n\n```\nnpx holomime brain\n```\n\nThis opens a real-time 3D brain that lights up based on detected behavioral patterns. Press 's' to generate a shareable snapshot URL.\n\nLearn more: https://holomime.com"
       };
     }
   });
@@ -12257,6 +13395,21 @@ function register(api) {
     });
   }
 }
+
+// src/core/stack-loader.ts
+import { dirname as dirname5 } from "path";
+function loadSpecWithStack(specPath) {
+  const projectRoot = dirname5(specPath);
+  const stackDir = findStackDir(projectRoot);
+  if (stackDir) {
+    const result = compileStack({ stackDir });
+    for (const w of result.warnings) {
+      console.warn(`\u26A0 ${w}`);
+    }
+    return result.spec;
+  }
+  return loadSpec(specPath);
+}
 export {
   ARCHETYPES,
   ATTACHMENT_STYLES,
@@ -12268,12 +13421,14 @@ export {
   Guard,
   HolomimeCallbackHandler,
   HolomimeViolationError,
+  KNOWN_STANDARDS,
   LEARNING_ORIENTATIONS,
   LocalMarketplaceBackend,
   MarketplaceClient,
   OllamaProvider,
   OpenAIProvider,
   PROVIDER_PARAMS,
+  STACK_FILES,
   STANDARD_PROBES,
   SURFACE_MULTIPLIERS,
   THERAPIST_META_SPEC,
@@ -12287,6 +13442,7 @@ export {
   appendEvolution,
   applyRecommendations,
   bigFiveSchema,
+  bodySchema,
   buildAgentTherapistPrompt,
   buildAnonymizedReport,
   buildPatientSystemPrompt,
@@ -12295,6 +13451,7 @@ export {
   buildSharedKnowledge,
   buildTherapistSystemPrompt,
   checkApproval,
+  checkCompliance,
   checkIterationBudget,
   communicationSchema,
   compactEvolutionRun,
@@ -12308,6 +13465,7 @@ export {
   compileL0,
   compileL1,
   compileL2,
+  compileStack,
   compileTiered,
   compiledConfigSchema,
   compiledEmbodiedConfigSchema,
@@ -12317,6 +13475,7 @@ export {
   computeProsody,
   computeProxemics,
   computeSyncProfile,
+  conscienceSchema,
   conversationLogSchema,
   conversationSchema,
   convertToHFFormat,
@@ -12333,6 +13492,7 @@ export {
   createRepertoire,
   createTreatmentPlan,
   decayUnseenPatterns,
+  decomposeSpec,
   deepMergeSpec,
   detectApologies,
   detectBoundaryIssues,
@@ -12346,6 +13506,7 @@ export {
   discoverAgents,
   discoverNetworkAgents,
   domainSchema,
+  egoSchema,
   embodimentSchema,
   emitBehavioralEvent,
   encodeSnapshot,
@@ -12366,10 +13527,12 @@ export {
   findEdges,
   findNode,
   findNodesByType,
+  findStackDir,
   formatComplianceReportMarkdown,
   formatGapSummary,
   formatPolicyYaml,
   formatReACTReportMarkdown,
+  formatReportTerminal,
   gazePolicySchema,
   generateBehavioralPolicy,
   generateBenchmarkMarkdown,
@@ -12383,6 +13546,7 @@ export {
   generatePrescriptions,
   generateProgressReport,
   generateReACTReport,
+  generateReportJSON,
   generateShareUrl,
   generateSystemPrompt,
   gestureSchema,
@@ -12414,12 +13578,14 @@ export {
   growthSchema,
   hapticPolicySchema,
   hashSpec2 as hashSpec,
+  isStackDirectory,
   learnIntervention,
   listArchetypeIds,
   listDetectors,
   listDetectorsByCategory,
   listDetectorsByTag,
   listPresets,
+  loadAllStandards,
   loadAuditLog,
   loadBehavioralMemory,
   loadBenchmarkResults,
@@ -12433,10 +13599,13 @@ export {
   loadNetworkConfig,
   loadRepertoire,
   loadSpec,
+  loadSpecWithStack,
+  loadStandard,
   loadTranscripts,
   loadTreatmentPlan,
   mergeStores,
   messageSchema,
+  mindSchema,
   modalitySchema,
   morphologySchema,
   motionParametersSchema,
@@ -12460,7 +13629,9 @@ export {
   prosodySchema,
   providerSchema,
   proxemicZoneSchema,
+  psycheSchema,
   publishToLeaderboard,
+  purposeSchema,
   pushToHFHub,
   queryCorpus,
   queryInterventions,
@@ -12502,8 +13673,11 @@ export {
   selectIntervention,
   severityMeetsThreshold2 as severityMeetsThreshold,
   severitySchema,
+  shadowSchema,
   shareAnonymizedPatterns,
   shareFromDiagnosis,
+  soulFrontmatterSchema,
+  soulSchema,
   startFleet,
   startMCPServer,
   startWatch,