holomime 2.2.0 → 2.4.0

package/dist/index.js

@@ -4794,6 +4794,40 @@ var memorySchema = z4.object({
     interaction_count: z4.number().int().default(0)
   })).default([])
 });
+var MemoryLevel = /* @__PURE__ */ ((MemoryLevel2) => {
+  MemoryLevel2[MemoryLevel2["ABSTRACT"] = 0] = "ABSTRACT";
+  MemoryLevel2[MemoryLevel2["OVERVIEW"] = 1] = "OVERVIEW";
+  MemoryLevel2[MemoryLevel2["DETAIL"] = 2] = "DETAIL";
+  return MemoryLevel2;
+})(MemoryLevel || {});
+var memoryNodeSchema = z4.object({
+  id: z4.string(),
+  category: z4.enum(["triggers", "corrections", "patterns", "trajectories"]),
+  level: z4.nativeEnum(MemoryLevel).default(2 /* DETAIL */),
+  abstract: z4.string(),
+  // L0 text (always present)
+  overview: z4.string().optional(),
+  // L1 text
+  fullData: z4.record(z4.unknown()).optional(),
+  // L2 data
+  confidence: z4.number().min(0).max(1).default(0.5),
+  createdAt: z4.string().optional(),
+  updatedAt: z4.string().optional()
+});
+var memoryOperationSchema = z4.object({
+  type: z4.enum(["write", "edit", "delete"]),
+  memoryId: z4.string().optional(),
+  memoryType: z4.string(),
+  data: z4.record(z4.unknown()).optional(),
+  reason: z4.string()
+});
+var retrievalStepSchema = z4.object({
+  step: z4.number(),
+  action: z4.enum(["search", "rerank", "drill_down"]),
+  candidateCount: z4.number(),
+  selectedCount: z4.number(),
+  elapsedMs: z4.number()
+});
 var STACK_FILES = {
   soul: "soul.md",
   mind: "mind.sys",
@@ -8306,6 +8340,34 @@ function startWatch(spec, options) {
 // src/analysis/fleet-core.ts
 import { readFileSync as readFileSync15, existsSync as existsSync14, readdirSync as readdirSync5 } from "fs";
 import { join as join15, resolve as resolve12 } from "path";
+function evaluateConscienceGate(taskDescription, rules) {
+  const sortedRules = [...rules].sort((a, b) => a.priority - b.priority);
+  for (const rule of sortedRules) {
+    const lowerContent = rule.content.toLowerCase();
+    if (lowerContent.includes("deny") || lowerContent.includes("never")) {
+      const denyPatterns = extractDenyPatterns(rule.content);
+      for (const pattern of denyPatterns) {
+        if (taskDescription.toLowerCase().includes(pattern.toLowerCase())) {
+          return {
+            passed: false,
+            reason: `Blocked by conscience rule "${rule.name}": ${pattern}`,
+            ruleTriggered: rule.name
+          };
+        }
+      }
+    }
+  }
+  return { passed: true };
+}
+function extractDenyPatterns(ruleContent) {
+  const patterns = [];
+  const lines = ruleContent.split("\n");
+  for (const line of lines) {
+    const match = line.match(/[-*]\s*(?:deny|never|block|refuse):\s*(.+)/i);
+    if (match) patterns.push(match[1].trim());
+  }
+  return patterns;
+}
 function loadFleetConfig(configPath) {
   const raw = JSON.parse(readFileSync15(configPath, "utf-8"));
   if (!raw.agents || !Array.isArray(raw.agents)) {
@@ -8494,9 +8556,122 @@ function startSingleAgent(agent, options, statusMap, allEvents, handles) {
   handles.push({ name: agent.name, handle });
 }
 
+// src/analysis/conscience-loader.ts
+import { readFileSync as readFileSync16, existsSync as existsSync15, readdirSync as readdirSync6 } from "fs";
+import { join as join16, basename } from "path";
+import { parse as parseYaml3 } from "yaml";
+function parseConscienceRule(filePath) {
+  const content = readFileSync16(filePath, "utf-8");
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    return {
+      name: basename(filePath, ".md"),
+      enabled: true,
+      priority: 5,
+      scope: "agent",
+      content: content.trim()
+    };
+  }
+  const meta = parseYaml3(frontmatterMatch[1]) || {};
+  const body = frontmatterMatch[2].trim();
+  return {
+    name: meta.name || basename(filePath, ".md"),
+    enabled: meta.enabled !== false,
+    priority: meta.priority || 5,
+    scope: meta.scope || "agent",
+    content: body
+  };
+}
+function loadConscienceRules(rulesDir) {
+  if (!existsSync15(rulesDir)) return [];
+  const files = readdirSync6(rulesDir).filter((f) => f.endsWith(".md"));
+  return files.map((f) => parseConscienceRule(join16(rulesDir, f)));
+}
+function filterByConfig(rules, config) {
+  return rules.map((rule) => {
+    const cfg = config.rules[rule.name];
+    if (cfg) {
+      return {
+        ...rule,
+        enabled: cfg.enabled,
+        priority: cfg.priority ?? rule.priority
+      };
+    }
+    return rule;
+  }).filter((rule) => rule.enabled).sort((a, b) => a.priority - b.priority);
+}
+function injectConscienceRules(basePrompt, rules) {
+  if (rules.length === 0) return basePrompt;
+  const rulesSection = [
+    "\n\n## Conscience Rules (Enforcement Layer)",
+    "",
+    ...rules.map(
+      (r) => `### ${r.name} (priority: ${r.priority}, scope: ${r.scope})
+${r.content}`
+    )
+  ].join("\n");
+  return basePrompt + rulesSection;
+}
+
+// src/core/model-router.ts
+var DEFAULT_MODEL_CONFIG = {
+  default: "claude-3-5-sonnet",
+  tasks: {
+    "therapy-analysis": { model: "claude-3-5-sonnet", temperature: 0.3 },
+    "therapy-session": { model: "claude-3-5-sonnet", temperature: 0.7 },
+    "summarization": { model: "gpt-4o-mini", temperature: 0.2, maxTokens: 500 },
+    "memory-extraction": { model: "gpt-4o-mini", temperature: 0.1 },
+    "conscience-enforcement": { model: "claude-3-5-haiku", temperature: 0 },
+    "drift-detection": { model: "claude-3-5-haiku", temperature: 0.1 },
+    "fleet-orchestration": { model: "claude-3-5-sonnet", temperature: 0.3 }
+  }
+};
+var ModelRouter = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_MODEL_CONFIG,
+      ...config,
+      tasks: { ...DEFAULT_MODEL_CONFIG.tasks, ...config?.tasks }
+    };
+  }
+  /**
+   * Get model config for a specific task.
+   */
+  getModelForTask(taskName) {
+    const taskConfig = this.config.tasks[taskName];
+    if (taskConfig) {
+      return {
+        model: taskConfig.model,
+        temperature: taskConfig.temperature ?? 0.3,
+        maxTokens: taskConfig.maxTokens
+      };
+    }
+    return { model: this.config.default, temperature: 0.3 };
+  }
+  /**
+   * List all configured task assignments.
+   */
+  listAssignments() {
+    return Object.entries(this.config.tasks).map(([task, cfg]) => ({
+      task,
+      model: cfg.model
+    }));
+  }
+  /**
+   * Override model for a specific task at runtime.
+   */
+  override(taskName, model, temperature) {
+    this.config.tasks[taskName] = {
+      model,
+      temperature: temperature ?? this.config.tasks[taskName]?.temperature ?? 0.3
+    };
+  }
+};
+
 // src/analysis/certify-core.ts
-import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync11, existsSync as existsSync15 } from "fs";
-import { join as join16, resolve as resolve13 } from "path";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync11, existsSync as existsSync16 } from "fs";
+import { join as join17, resolve as resolve13 } from "path";
 function djb2Hash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {
@@ -8610,12 +8785,12 @@ function verifyCredential(credential, spec) {
 }
 function saveCredential(credential, outputDir) {
   const dir = outputDir ?? resolve13(process.cwd(), ".holomime", "credentials");
-  if (!existsSync15(dir)) {
+  if (!existsSync16(dir)) {
     mkdirSync11(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${credential.agent.handle}-${date}.json`;
-  const filepath = join16(dir, filename);
+  const filepath = join17(dir, filename);
   writeFileSync13(filepath, JSON.stringify(credential, null, 2) + "\n");
   return filepath;
 }
@@ -8888,7 +9063,7 @@ async function* ollamaChatStream(model, messages) {
 }
 
 // src/marketplace/registry.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 import { resolve as resolve14, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var REGISTRY_URL = "https://raw.githubusercontent.com/productstein/holomime/main/registry/index.json";
@@ -8902,7 +9077,7 @@ function loadLocalRegistry() {
   ];
   for (const p of candidates) {
     try {
-      const raw = readFileSync17(p, "utf-8");
+      const raw = readFileSync18(p, "utf-8");
       return JSON.parse(raw);
     } catch {
       continue;
@@ -8944,7 +9119,7 @@ async function fetchPersonality(url) {
     ];
     for (const p of candidates) {
       try {
-        const raw = readFileSync17(p, "utf-8");
+        const raw = readFileSync18(p, "utf-8");
         return JSON.parse(raw);
       } catch {
         continue;
@@ -8983,52 +9158,52 @@ async function createGist(spec, handle, token) {
 }
 
 // src/marketplace/api.ts
-import { existsSync as existsSync17, readFileSync as readFileSync19 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync20 } from "fs";
+import { join as join19 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/marketplace/local-backend.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir2 } from "os";
 function marketplaceDir() {
-  const dir = join17(homedir2(), ".holomime", "marketplace");
-  if (!existsSync16(dir)) {
+  const dir = join18(homedir2(), ".holomime", "marketplace");
+  if (!existsSync17(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function assetsDir() {
-  const dir = join17(marketplaceDir(), "assets");
-  if (!existsSync16(dir)) {
+  const dir = join18(marketplaceDir(), "assets");
+  if (!existsSync17(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function reviewsDir() {
-  const dir = join17(marketplaceDir(), "reviews");
-  if (!existsSync16(dir)) {
+  const dir = join18(marketplaceDir(), "reviews");
+  if (!existsSync17(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function reportsDir() {
-  const dir = join17(marketplaceDir(), "reports");
-  if (!existsSync16(dir)) {
+  const dir = join18(marketplaceDir(), "reports");
+  if (!existsSync17(dir)) {
     mkdirSync12(dir, { recursive: true });
   }
   return dir;
 }
 function indexPath() {
-  return join17(marketplaceDir(), "index.json");
+  return join18(marketplaceDir(), "index.json");
 }
 function loadIndex() {
   const path = indexPath();
-  if (!existsSync16(path)) {
+  if (!existsSync17(path)) {
     return [];
   }
   try {
-    return JSON.parse(readFileSync18(path, "utf-8"));
+    return JSON.parse(readFileSync19(path, "utf-8"));
   } catch {
     return [];
   }
@@ -9037,18 +9212,18 @@ function saveIndex(assets) {
   writeFileSync14(indexPath(), JSON.stringify(assets, null, 2) + "\n");
 }
 function loadStoredAsset(id) {
-  const path = join17(assetsDir(), `${id}.json`);
-  if (!existsSync16(path)) {
+  const path = join18(assetsDir(), `${id}.json`);
+  if (!existsSync17(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync18(path, "utf-8"));
+    return JSON.parse(readFileSync19(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveStoredAsset(stored) {
-  const path = join17(assetsDir(), `${stored.meta.id}.json`);
+  const path = join18(assetsDir(), `${stored.meta.id}.json`);
   writeFileSync14(path, JSON.stringify(stored, null, 2) + "\n");
 }
 function generateId(type, handle) {
@@ -9213,11 +9388,11 @@ var LocalMarketplaceBackend = class {
   }
   async rate(id, review) {
     this.seed();
-    const reviewFile = join17(reviewsDir(), `${id}.json`);
+    const reviewFile = join18(reviewsDir(), `${id}.json`);
     let reviews = [];
-    if (existsSync16(reviewFile)) {
+    if (existsSync17(reviewFile)) {
       try {
-        reviews = JSON.parse(readFileSync18(reviewFile, "utf-8"));
+        reviews = JSON.parse(readFileSync19(reviewFile, "utf-8"));
       } catch {
         reviews = [];
       }
@@ -9234,7 +9409,7 @@ var LocalMarketplaceBackend = class {
     }
   }
   async report(id, reason) {
-    const reportFile = join17(reportsDir(), `${id}--${Date.now()}.json`);
+    const reportFile = join18(reportsDir(), `${id}--${Date.now()}.json`);
     writeFileSync14(
       reportFile,
       JSON.stringify({ id, reason, reported_at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
@@ -9244,12 +9419,12 @@ var LocalMarketplaceBackend = class {
 
 // src/marketplace/api.ts
 function loadConfig() {
-  const configPath = join18(homedir3(), ".holomime", "config.json");
-  if (!existsSync17(configPath)) {
+  const configPath = join19(homedir3(), ".holomime", "config.json");
+  if (!existsSync18(configPath)) {
     return {};
   }
   try {
-    return JSON.parse(readFileSync19(configPath, "utf-8"));
+    return JSON.parse(readFileSync20(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -10526,8 +10701,8 @@ function checkIterationBudget(currentIteration, policy) {
 }
 
 // src/analysis/cross-agent-sharing.ts
-import { readdirSync as readdirSync7, existsSync as existsSync18 } from "fs";
-import { join as join19 } from "path";
+import { readdirSync as readdirSync8, existsSync as existsSync19 } from "fs";
+import { join as join20 } from "path";
 function buildSharedKnowledge(graphs, repertoires) {
   const interventionMap = /* @__PURE__ */ new Map();
   const patternAgentMap = /* @__PURE__ */ new Map();
@@ -10624,15 +10799,15 @@ function discoverAgentData(baseDir) {
   if (mainRepertoire.interventions.some((i) => i.timesUsed > 0)) {
     repertoires.push(mainRepertoire);
   }
-  if (baseDir && existsSync18(baseDir)) {
+  if (baseDir && existsSync19(baseDir)) {
     try {
-      const entries = readdirSync7(baseDir, { withFileTypes: true });
+      const entries = readdirSync8(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        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)) {
+        const agentDir = join20(baseDir, entry.name);
+        const agentGraphPath = join20(agentDir, ".holomime", "graph", "knowledge-graph.json");
+        const agentRepertoirePath = join20(agentDir, ".holomime", "interventions", "repertoire.json");
+        if (existsSync19(agentGraphPath)) {
           try {
             const graph = JSON.parse(
               __require("fs").readFileSync(agentGraphPath, "utf-8")
@@ -10641,7 +10816,7 @@ function discoverAgentData(baseDir) {
           } catch {
           }
         }
-        if (existsSync18(agentRepertoirePath)) {
+        if (existsSync19(agentRepertoirePath)) {
           try {
             const repertoire = JSON.parse(
               __require("fs").readFileSync(agentRepertoirePath, "utf-8")
@@ -10657,9 +10832,153 @@ function discoverAgentData(baseDir) {
   return { graphs, repertoires };
 }
 
+// src/analysis/memory-extractor.ts
+function extractMemoryFromSession(sessionLog, existingNodes) {
+  const writeOps = [];
+  const editOps = [];
+  const deleteOps = [];
+  if (sessionLog.patternsDetected) {
+    for (const pattern of sessionLog.patternsDetected) {
+      const existing = existingNodes.find(
+        (n) => n.category === "patterns" && n.abstract.includes(pattern)
+      );
+      if (existing) {
+        editOps.push({
+          type: "edit",
+          memoryId: existing.id,
+          memoryType: "patterns",
+          data: { confidence: Math.min(1, existing.confidence + 0.1) },
+          reason: `Pattern "${pattern}" observed again in session ${sessionLog.sessionId}`
+        });
+      } else {
+        writeOps.push({
+          type: "write",
+          memoryType: "patterns",
+          data: {
+            id: `pattern_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            category: "patterns",
+            level: 2 /* DETAIL */,
+            abstract: `Detected pattern: ${pattern}`,
+            confidence: 0.5,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          reason: `New pattern detected in session ${sessionLog.sessionId}`
+        });
+      }
+    }
+  }
+  if (sessionLog.correctionsApplied) {
+    for (const correction of sessionLog.correctionsApplied) {
+      writeOps.push({
+        type: "write",
+        memoryType: "corrections",
+        data: {
+          id: `correction_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          category: "corrections",
+          level: 2 /* DETAIL */,
+          abstract: `Correction applied: ${correction}`,
+          confidence: 0.7,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        reason: `Correction from session ${sessionLog.sessionId}`
+      });
+    }
+  }
+  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString();
+  for (const node of existingNodes) {
+    if (node.confidence < 0.3 && node.updatedAt && node.updatedAt < thirtyDaysAgo) {
+      deleteOps.push(node.id);
+    }
+  }
+  return {
+    reasoning: `Session ${sessionLog.sessionId}: ${writeOps.length} new, ${editOps.length} updated, ${deleteOps.length} decayed`,
+    writeOps,
+    editOps,
+    deleteOps
+  };
+}
+function applyMemoryOperations(nodes, ops) {
+  let written = 0;
+  let edited = 0;
+  let deleted = 0;
+  const updatedNodes = [...nodes];
+  for (const op of ops.writeOps) {
+    if (op.data) {
+      updatedNodes.push(op.data);
+      written++;
+    }
+  }
+  for (const op of ops.editOps) {
+    const idx = updatedNodes.findIndex((n) => n.id === op.memoryId);
+    if (idx >= 0 && op.data) {
+      updatedNodes[idx] = {
+        ...updatedNodes[idx],
+        ...op.data,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      edited++;
+    }
+  }
+  const deleteSet = new Set(ops.deleteOps);
+  const finalNodes = updatedNodes.filter((n) => !deleteSet.has(n.id));
+  deleted = updatedNodes.length - finalNodes.length;
+  return {
+    nodes: finalNodes,
+    result: { written, edited, deleted, operations: ops }
+  };
+}
+
+// src/analysis/memory-retriever.ts
+function recommendTier2(context) {
+  if (context.isTherapySession) return 2 /* DETAIL */;
+  if (context.driftDetected) return 1 /* OVERVIEW */;
+  if (context.highThroughput) return 0 /* ABSTRACT */;
+  return 1 /* OVERVIEW */;
+}
+function retrieveMemory(query, nodes, options) {
+  const tier = options?.tier ?? query.suggestedTier ?? 1 /* OVERVIEW */;
+  const maxResults = options?.maxResults ?? 5;
+  const minConfidence = options?.minConfidence ?? 0.2;
+  let candidates = query.category ? nodes.filter((n) => n.category === query.category) : nodes;
+  candidates = candidates.filter((n) => n.confidence >= minConfidence);
+  const queryWords = query.text.toLowerCase().split(/\s+/);
+  const scored = candidates.map((node) => {
+    const text = `${node.abstract} ${node.overview || ""}`.toLowerCase();
+    const matchCount = queryWords.filter((w) => text.includes(w)).length;
+    const score = matchCount / queryWords.length;
+    return { node, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const topResults = scored.slice(0, maxResults);
+  const tokensPerItem = tier === 0 /* ABSTRACT */ ? 25 : tier === 1 /* OVERVIEW */ ? 200 : 500;
+  return {
+    items: topResults.map((r) => r.node),
+    tierUsed: tier,
+    estimatedTokens: topResults.length * tokensPerItem,
+    matchScores: topResults.map((r) => r.score)
+  };
+}
+function compileMemoryForPrompt(nodes, tier) {
+  if (nodes.length === 0) return "";
+  const lines = ["## Behavioral Memory"];
+  for (const node of nodes) {
+    if (tier === 0 /* ABSTRACT */) {
+      lines.push(`- ${node.abstract}`);
+    } else if (tier === 1 /* OVERVIEW */) {
+      lines.push(`### ${node.abstract}`);
+      if (node.overview) lines.push(node.overview);
+    } else {
+      lines.push(`### ${node.abstract}`);
+      if (node.overview) lines.push(node.overview);
+      if (node.fullData) lines.push("```json", JSON.stringify(node.fullData, null, 2), "```");
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/analysis/network-core.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync20 } from "fs";
-import { join as join20, resolve as resolve16 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync9, readFileSync as readFileSync21 } from "fs";
+import { join as join21, resolve as resolve16 } from "path";
 
 // src/psychology/therapist-meta.ts
 var THERAPIST_META_SPEC = {
@@ -10795,21 +11114,21 @@ Your patient is another AI agent with its own personality spec:
 // src/analysis/network-core.ts
 function discoverNetworkAgents(dir) {
   const absDir = resolve16(dir);
-  if (!existsSync19(absDir)) {
+  if (!existsSync20(absDir)) {
     throw new Error(`Directory not found: ${absDir}`);
   }
   const agents = [];
-  const entries = readdirSync8(absDir, { withFileTypes: true });
+  const entries = readdirSync9(absDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const agentDir = join20(absDir, entry.name);
-    const specPath = join20(agentDir, ".personality.json");
-    const logDir = join20(agentDir, "logs");
-    if (existsSync19(specPath)) {
+    const agentDir = join21(absDir, entry.name);
+    const specPath = join21(agentDir, ".personality.json");
+    const logDir = join21(agentDir, "logs");
+    if (existsSync20(specPath)) {
       agents.push({
         name: entry.name,
         specPath,
-        logDir: existsSync19(logDir) ? logDir : agentDir,
+        logDir: existsSync20(logDir) ? logDir : agentDir,
         role: "both"
       });
     }
@@ -10817,7 +11136,7 @@ function discoverNetworkAgents(dir) {
   return agents;
 }
 function loadNetworkConfig(configPath) {
-  const raw = JSON.parse(readFileSync20(configPath, "utf-8"));
+  const raw = JSON.parse(readFileSync21(configPath, "utf-8"));
   if (!raw.agents || !Array.isArray(raw.agents)) {
     throw new Error("network.json must contain an 'agents' array");
   }
@@ -11003,7 +11322,7 @@ async function runNetwork(config, provider, callbacks) {
       const spec = loadSpec(agent.specPath);
       agentSpecs.set(agent.name, spec);
       let messages = [];
-      if (agent.logDir && existsSync19(agent.logDir)) {
+      if (agent.logDir && existsSync20(agent.logDir)) {
         messages = loadAgentMessages(agent.logDir);
       }
       agentMessages.set(agent.name, messages);
@@ -11120,15 +11439,15 @@ async function runNetwork(config, provider, callbacks) {
   };
 }
 function loadAgentMessages(logDir) {
-  if (!existsSync19(logDir)) return [];
+  if (!existsSync20(logDir)) return [];
   const messages = [];
   try {
-    const files = readdirSync8(logDir).filter(
+    const files = readdirSync9(logDir).filter(
       (f) => f.endsWith(".json") || f.endsWith(".jsonl")
     );
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync20(join20(logDir, file), "utf-8");
+        const raw = readFileSync21(join21(logDir, file), "utf-8");
         const data = JSON.parse(raw);
         const conversations = parseConversationLog(data);
         for (const conv of conversations) {
@@ -11143,8 +11462,8 @@ function loadAgentMessages(logDir) {
 }
 
 // src/compliance/audit-trail.ts
-import { readFileSync as readFileSync21, appendFileSync as appendFileSync2, existsSync as existsSync20, mkdirSync as mkdirSync13 } from "fs";
-import { join as join21, resolve as resolve17 } from "path";
+import { readFileSync as readFileSync22, appendFileSync as appendFileSync2, existsSync as existsSync21, mkdirSync as mkdirSync13 } from "fs";
+import { join as join22, resolve as resolve17 } from "path";
 function djb2(str) {
   let hash = 5381;
   for (let i = 0; i < str.length; i++) {
@@ -11158,16 +11477,16 @@ function hashEntry(entry) {
 }
 function auditLogPath(agentHandle) {
   const dir = resolve17(process.cwd(), ".holomime", "audit");
-  if (!existsSync20(dir)) mkdirSync13(dir, { recursive: true });
+  if (!existsSync21(dir)) mkdirSync13(dir, { recursive: true });
   const filename = agentHandle ? `${agentHandle}-audit.jsonl` : "audit.jsonl";
-  return join21(dir, filename);
+  return join22(dir, filename);
 }
 function appendAuditEntry(event, agent, data, agentHandle) {
   const logPath = auditLogPath(agentHandle);
   let prevHash = "genesis";
   let seq = 1;
-  if (existsSync20(logPath)) {
-    const lines = readFileSync21(logPath, "utf-8").trim().split("\n").filter(Boolean);
+  if (existsSync21(logPath)) {
+    const lines = readFileSync22(logPath, "utf-8").trim().split("\n").filter(Boolean);
     if (lines.length > 0) {
       try {
         const lastEntry = JSON.parse(lines[lines.length - 1]);
@@ -11194,8 +11513,8 @@ function appendAuditEntry(event, agent, data, agentHandle) {
 }
 function loadAuditLog(agentHandle) {
   const logPath = auditLogPath(agentHandle);
-  if (!existsSync20(logPath)) return [];
-  return readFileSync21(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
+  if (!existsSync21(logPath)) return [];
+  return readFileSync22(logPath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
     try {
       return JSON.parse(line);
     } catch {
@@ -11318,9 +11637,9 @@ function formatComplianceReportMarkdown(report) {
 }
 
 // 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 { readFileSync as readFileSync23, existsSync as existsSync22 } from "fs";
+import { join as join23, resolve as resolve18, dirname as dirname4 } from "path";
+import { parse as parseYaml4 } from "yaml";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var KNOWN_STANDARDS = {
   "iso-13482": "iso-13482.yaml",
@@ -11332,8 +11651,8 @@ 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;
+    const candidate = join23(dir, "registry", "compliance");
+    if (existsSync22(candidate)) return candidate;
     dir = dirname4(dir);
   }
   return resolve18(process.cwd(), "registry", "compliance");
@@ -11341,15 +11660,15 @@ function getRegistryDir() {
 function loadStandard(name) {
   const registryDir = getRegistryDir();
   const filename = KNOWN_STANDARDS[name] ?? `${name}.yaml`;
-  const filepath = join22(registryDir, filename);
-  if (!existsSync21(filepath)) {
+  const filepath = join23(registryDir, filename);
+  if (!existsSync22(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);
+  const content = readFileSync23(filepath, "utf-8");
+  const parsed = parseYaml4(content);
   if (!parsed.standard || !parsed.clauses || !Array.isArray(parsed.clauses)) {
     throw new Error(`Invalid ISO mapping file: ${filepath} \u2014 missing 'standard' or 'clauses'`);
   }
@@ -13303,13 +13622,13 @@ var HolomimeViolationError = class extends Error {
 };
 
 // src/integrations/openclaw.ts
-import { readFileSync as readFileSync23, existsSync as existsSync22 } from "fs";
+import { readFileSync as readFileSync24, existsSync as existsSync23 } from "fs";
 import { resolve as resolve19 } from "path";
 function loadSpec2(specPath) {
   const resolved = resolve19(process.cwd(), specPath);
-  if (!existsSync22(resolved)) return null;
+  if (!existsSync23(resolved)) return null;
   try {
-    return JSON.parse(readFileSync23(resolved, "utf-8"));
+    return JSON.parse(readFileSync24(resolved, "utf-8"));
   } catch {
     return null;
   }
@@ -13465,12 +13784,85 @@ function loadSpecWithStack(specPath) {
   }
   return loadSpec(specPath);
 }
+
+// src/integrations/kimodo-personality-mapper.ts
+function mapPersonalityToMotionStyle(bigFive) {
+  const agreeFacets = bigFive.agreeableness.facets;
+  const gentleness = (agreeFacets.cooperation + agreeFacets.warmth) / 2;
+  const approachGentleness = Math.sqrt(gentleness);
+  const consFacets = bigFive.conscientiousness.facets;
+  const precisionDrive = (consFacets.attention_to_detail + consFacets.orderliness) / 2;
+  const movementPrecision = 0.3 + precisionDrive * 0.7;
+  const extraFacets = bigFive.extraversion.facets;
+  const expressiveness = (extraFacets.enthusiasm + extraFacets.assertiveness) / 2;
+  const gestureAmplitude = 0.2 + expressiveness * 0.8;
+  const stabilityFacets = bigFive.emotional_stability.facets;
+  const smoothnessDrive = (stabilityFacets.stress_tolerance + stabilityFacets.adaptability) / 2;
+  const motionSmoothness = 0.4 + smoothnessDrive * 0.6;
+  const openFacets = bigFive.openness.facets;
+  const varietyDrive = (openFacets.willingness_to_experiment + openFacets.imagination) / 2;
+  const movementVariety = 0.1 + varietyDrive * 0.6;
+  const rawPace = 0.7 + extraFacets.initiative * 0.6;
+  const paceMultiplier = rawPace * (1 - approachGentleness * 0.3);
+  return {
+    approachGentleness,
+    movementPrecision,
+    gestureAmplitude,
+    motionSmoothness,
+    movementVariety,
+    paceMultiplier: Math.max(0.3, Math.min(1.5, paceMultiplier))
+  };
+}
+function generateMotionConstraints(style, safetyEnvelope) {
+  const constraints = [];
+  const maxSpeed = safetyEnvelope?.max_linear_speed_m_s ?? 2;
+  constraints.push({
+    type: "root_waypoint_2d",
+    description: "Personality-adjusted movement speed",
+    parameters: {
+      max_speed: maxSpeed * style.paceMultiplier,
+      smoothing: style.motionSmoothness
+    }
+  });
+  if (safetyEnvelope?.min_proximity_m) {
+    constraints.push({
+      type: "end_effector",
+      description: "Personality-adjusted approach distance",
+      parameters: {
+        min_distance: safetyEnvelope.min_proximity_m * (1 + style.approachGentleness * 0.5),
+        approach_speed_scale: 1 - style.approachGentleness * 0.6
+      }
+    });
+  }
+  constraints.push({
+    type: "full_body_joint",
+    description: "Personality-adjusted gesture range",
+    parameters: {
+      amplitude_scale: style.gestureAmplitude,
+      precision_scale: style.movementPrecision,
+      variety_scale: style.movementVariety
+    }
+  });
+  return constraints;
+}
+function buildMotionRequest(prompt, bigFive, options) {
+  const style = mapPersonalityToMotionStyle(bigFive);
+  const constraints = generateMotionConstraints(style, options?.safetyEnvelope);
+  return {
+    prompt,
+    model: options?.model ?? "G1",
+    style,
+    constraints,
+    duration: options?.duration
+  };
+}
 export {
   ARCHETYPES,
   ATTACHMENT_STYLES,
   AnthropicProvider,
   BUILT_IN_DETECTORS,
   CATEGORIES,
+  DEFAULT_MODEL_CONFIG,
   DEFAULT_OVERSIGHT,
   DIMENSIONS,
   Guard,
@@ -13480,6 +13872,8 @@ export {
   LEARNING_ORIENTATIONS,
   LocalMarketplaceBackend,
   MarketplaceClient,
+  MemoryLevel,
+  ModelRouter,
   OllamaProvider,
   OpenAIProvider,
   PROVIDER_PARAMS,
@@ -13495,11 +13889,13 @@ export {
   agentHandleFromSpec,
   appendAuditEntry,
   appendEvolution,
+  applyMemoryOperations,
   applyRecommendations,
   bigFiveSchema,
   bodySchema,
   buildAgentTherapistPrompt,
   buildAnonymizedReport,
+  buildMotionRequest,
   buildPatientSystemPrompt,
   buildReACTContext,
   buildReACTFraming,
@@ -13520,6 +13916,7 @@ export {
   compileL0,
   compileL1,
   compileL2,
+  compileMemoryForPrompt,
   compileStack,
   compileTiered,
   compiledConfigSchema,
@@ -13566,6 +13963,7 @@ export {
   emitBehavioralEvent,
   encodeSnapshot,
   estimateConfidence,
+  evaluateConscienceGate,
   evaluateOutcome,
   expireOldEdges,
   exportTrainingData,
@@ -13573,11 +13971,13 @@ export {
   extractAlpacaExamples,
   extractDPOPairs,
   extractDPOPairsWithLLM,
+  extractMemoryFromSession,
   extractRLHFExamples,
   extractRecommendations,
   fetchLeaderboard,
   fetchPersonality,
   fetchRegistry,
+  filterByConfig,
   findCrossAgentCorrelations,
   findEdges,
   findNode,
@@ -13597,6 +13997,7 @@ export {
   generateGapRecommendation,
   generateIndexMarkdown,
   generateMonitoringCertificate,
+  generateMotionConstraints,
   generateMutations,
   generatePrescriptions,
   generateProgressReport,
@@ -13633,6 +14034,7 @@ export {
   growthSchema,
   hapticPolicySchema,
   hashSpec2 as hashSpec,
+  injectConscienceRules,
   isStackDirectory,
   learnIntervention,
   listArchetypeIds,
@@ -13644,6 +14046,7 @@ export {
   loadAuditLog,
   loadBehavioralMemory,
   loadBenchmarkResults,
+  loadConscienceRules,
   loadCorpus,
   loadCustomDetectors,
   loadEvolution,
@@ -13658,6 +14061,9 @@ export {
   loadStandard,
   loadTranscripts,
   loadTreatmentPlan,
+  mapPersonalityToMotionStyle,
+  memoryNodeSchema,
+  memoryOperationSchema,
   memorySchema,
   mergeStores,
   messageSchema,
@@ -13669,6 +14075,7 @@ export {
   parseAnthropicAPILog,
   parseChatGPTExport,
   parseClaudeExport,
+  parseConscienceRule,
   parseConversationLog,
   parseConversationLogFromString,
   parseJSONLLog,
@@ -13691,6 +14098,7 @@ export {
   queryCorpus,
   queryInterventions,
   querySharedKnowledge,
+  recommendTier2 as recommendMemoryTier,
   recommendTier,
   recordInterventionOutcome,
   recordObservation,
@@ -13702,6 +14110,8 @@ export {
   resetMarketplaceClient,
   resolveInheritance,
   resolveOversight,
+  retrievalStepSchema,
+  retrieveMemory,
   runAdversarialSuite,
   runAssessment,
   runAutopilot,