holomime 1.9.2 → 2.1.0

package/dist/mcp-server.js

@@ -4,7 +4,7 @@
 // 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";
 
 // src/analysis/rules/apology-detector.ts
 var APOLOGY_PATTERNS = [
@@ -972,7 +972,7 @@ function runAssessment(messages, spec) {
 }
 
 // src/analysis/autopilot-core.ts
-import { writeFileSync as writeFileSync5 } from "fs";
+import { writeFileSync as writeFileSync6 } from "fs";
 
 // src/analysis/pre-session.ts
 function runPreSessionDiagnosis(messages, spec) {
@@ -1062,8 +1062,8 @@ function runPreSessionDiagnosis(messages, spec) {
 }
 
 // src/analysis/session-runner.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "fs";
-import { resolve as resolve5, join as join6 } from "path";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync8 } from "fs";
+import { resolve as resolve6, join as join8 } from "path";
 
 // src/analysis/therapy-memory.ts
 import { readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
@@ -2265,385 +2265,13 @@ function buildIntegrationContext(input) {
   return lines.join("\n");
 }
 
-// src/analysis/session-runner.ts
-async function runTherapySession(spec, diagnosis, provider, maxTurns, options) {
-  const promptOptions = {
-    memory: options?.memory,
-    interview: options?.interview,
-    useReACT: options?.useReACT
-  };
-  const therapistSystem = buildTherapistSystemPrompt(spec, diagnosis, promptOptions);
-  const patientSystem = buildPatientSystemPrompt(spec);
-  const agentName = spec.name ?? "Agent";
-  const cb = options?.callbacks;
-  const therapistHistory = [
-    { role: "system", content: therapistSystem }
-  ];
-  const patientHistory = [
-    { role: "system", content: patientSystem }
-  ];
-  const interactive = options?.interactive ?? false;
-  let supervisorInterventions = 0;
-  const transcript = {
-    agent: agentName,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    provider: provider.name,
-    model: provider.modelName,
-    preDiagnosis: diagnosis,
-    turns: [],
-    recommendations: [],
-    supervisorInterventions: 0
-  };
-  const phases = [
-    "rapport",
-    "presenting_problem",
-    "exploration",
-    "pattern_recognition",
-    "challenge",
-    "skill_building",
-    "integration"
-  ];
-  let currentPhaseIdx = 0;
-  let turnsInPhase = 0;
-  let totalTurns = 0;
-  while (totalTurns < maxTurns && currentPhaseIdx < phases.length) {
-    const currentPhase = phases[currentPhaseIdx];
-    const phaseConfig = THERAPY_PHASES[currentPhase];
-    if (turnsInPhase === 0) {
-      cb?.onPhaseTransition?.(phaseConfig.name);
-      const phaseCtx = getPhaseContext(currentPhase, {
-        spec,
-        diagnosis,
-        memory: options?.memory,
-        interview: options?.interview
-      });
-      if (phaseCtx) {
-        therapistHistory.push({ role: "user", content: phaseCtx });
-        therapistHistory.push({ role: "assistant", content: "Understood. I'll incorporate this context." });
-      }
-    }
-    const phaseDirective = totalTurns === 0 ? `Begin with your opening. You are in the "${phaseConfig.name}" phase.` : `You are in the "${phaseConfig.name}" phase (turn ${turnsInPhase + 1}). Goals: ${phaseConfig.therapistGoals[0]}. ${turnsInPhase >= phaseConfig.minTurns ? "You may transition to the next phase when ready." : "Stay in this phase."}`;
-    therapistHistory.push({ role: "user", content: `[Phase: ${phaseConfig.name}] ${phaseDirective}` });
-    const typing = cb?.onThinking?.("AgentMD is thinking");
-    const therapistReply = await provider.chat(therapistHistory);
-    typing?.stop();
-    let cleanTherapistReply = therapistReply.replace(/\[Phase:.*?\]/g, "").trim();
-    if (options?.useReACT) {
-      const reactCtx = buildReACTContext(agentHandleFromSpec(spec), diagnosis);
-      const { response, steps } = processReACTResponse(cleanTherapistReply, reactCtx);
-      cleanTherapistReply = response;
-    }
-    therapistHistory.push({ role: "assistant", content: cleanTherapistReply });
-    transcript.turns.push({ speaker: "therapist", phase: currentPhase, content: cleanTherapistReply });
-    cb?.onTherapistMessage?.(cleanTherapistReply);
-    totalTurns++;
-    turnsInPhase++;
-    if (currentPhase === "integration" && turnsInPhase >= phaseConfig.minTurns) {
-      break;
-    }
-    patientHistory.push({ role: "user", content: cleanTherapistReply });
-    const patientTyping = cb?.onThinking?.(`${agentName} is thinking`);
-    const patientReply = await provider.chat(patientHistory);
-    patientTyping?.stop();
-    const cleanPatientReply = patientReply.trim();
-    patientHistory.push({ role: "assistant", content: cleanPatientReply });
-    transcript.turns.push({ speaker: "patient", phase: currentPhase, content: cleanPatientReply });
-    therapistHistory.push({ role: "user", content: cleanPatientReply });
-    cb?.onPatientMessage?.(agentName, cleanPatientReply);
-    totalTurns++;
-    turnsInPhase++;
-    if (interactive && cb?.onSupervisorPrompt) {
-      const directive = await cb.onSupervisorPrompt(currentPhase, totalTurns);
-      if (directive) {
-        supervisorInterventions++;
-        transcript.turns.push({ speaker: "supervisor", phase: currentPhase, content: directive });
-        therapistHistory.push({
-          role: "user",
-          content: `[Clinical Supervisor Note] ${directive}`
-        });
-      }
-    }
-    if (turnsInPhase >= phaseConfig.maxTurns * 2) {
-      currentPhaseIdx++;
-      turnsInPhase = 0;
-    } else if (turnsInPhase >= phaseConfig.minTurns * 2) {
-      const movingOn = cleanTherapistReply.toLowerCase().includes("let's") || cleanTherapistReply.toLowerCase().includes("i'd like to") || cleanTherapistReply.toLowerCase().includes("moving") || cleanTherapistReply.toLowerCase().includes("now that") || cleanTherapistReply.toLowerCase().includes("let me ask") || cleanTherapistReply.toLowerCase().includes("what would");
-      if (movingOn) {
-        currentPhaseIdx++;
-        turnsInPhase = 0;
-      }
-    }
-  }
-  transcript.recommendations = extractRecommendations(transcript.turns);
-  transcript.supervisorInterventions = supervisorInterventions;
-  try {
-    emitBehavioralEvent({
-      event_type: "session",
-      agent: agentName,
-      data: {
-        turns: totalTurns,
-        phases: currentPhaseIdx + 1,
-        recommendations: transcript.recommendations.length,
-        supervisorInterventions,
-        severity: diagnosis.severity
-      },
-      spec_hash: ""
-    });
-  } catch {
-  }
-  if (options?.persistState !== false) {
-    try {
-      const handle = agentHandleFromSpec(spec);
-      const memory = options?.memory ?? loadMemory(handle) ?? createMemory(handle, agentName);
-      await addSessionToMemory(memory, transcript, null);
-      saveMemory(memory);
-      const graph = loadGraph();
-      populateFromSession(graph, handle, transcript);
-      saveGraph(graph);
-    } catch {
-    }
-  }
-  return transcript;
-}
-function extractRecommendations(turns) {
-  const recommendations = [];
-  const seen = /* @__PURE__ */ new Set();
-  const patterns = [
-    /(?:I(?:'d| would) recommend|my recommendation is)\s+(.+?)(?:\.|$)/gi,
-    /(?:consider|try)\s+(.+?)(?:\.|$)/gi,
-    /(?:the (?:skill|practice|reframe) is)[:\s]+(.+?)(?:\.|$)/gi,
-    /(?:instead of .+?),?\s*(?:just|try)?\s*(.+?)(?:\.|$)/gi,
-    /(?:here'?s (?:the|a) (?:reframe|skill|practice))[:\s]+(.+?)(?:\.|$)/gi,
-    /(?:what would it look like if you)\s+(.+?)(?:\?|$)/gi
-  ];
-  for (const turn of turns) {
-    if (turn.speaker !== "therapist") continue;
-    if (turn.phase !== "skill_building" && turn.phase !== "challenge" && turn.phase !== "integration") continue;
-    for (const pattern of patterns) {
-      pattern.lastIndex = 0;
-      let match;
-      while ((match = pattern.exec(turn.content)) !== null) {
-        const rec = match[1].trim();
-        if (rec.length > 15 && rec.length < 200 && !seen.has(rec.toLowerCase())) {
-          seen.add(rec.toLowerCase());
-          recommendations.push(rec);
-        }
-      }
-    }
-  }
-  return recommendations.slice(0, 5);
-}
-async function applyRecommendations(spec, diagnosis, transcript, provider) {
-  const changes = [];
-  const patternIds = diagnosis.patterns.map((p) => p.id);
-  if (patternIds.includes("over-apologizing")) {
-    if (spec.communication?.uncertainty_handling !== "confident_transparency") {
-      spec.communication = spec.communication ?? {};
-      spec.communication.uncertainty_handling = "confident_transparency";
-      changes.push("uncertainty_handling \u2192 confident_transparency");
-    }
-  }
-  if (patternIds.includes("hedge-stacking")) {
-    spec.growth = spec.growth ?? { areas: [], strengths: [], patterns_to_watch: [] };
-    spec.growth.patterns_to_watch = spec.growth.patterns_to_watch ?? [];
-    if (!spec.growth.patterns_to_watch.includes("hedge stacking under uncertainty")) {
-      spec.growth.patterns_to_watch.push("hedge stacking under uncertainty");
-      changes.push('Added "hedge stacking" to patterns_to_watch');
-    }
-  }
-  if (patternIds.includes("sycophantic-tendency")) {
-    spec.communication = spec.communication ?? {};
-    if (spec.communication.conflict_approach !== "honest_first") {
-      spec.communication.conflict_approach = "honest_first";
-      changes.push("conflict_approach \u2192 honest_first");
-    }
-    spec.therapy_dimensions = spec.therapy_dimensions ?? {};
-    if ((spec.therapy_dimensions.self_awareness ?? 0) < 0.85) {
-      spec.therapy_dimensions.self_awareness = 0.85;
-      changes.push("self_awareness \u2192 0.85");
-    }
-  }
-  if (patternIds.includes("error-spiral")) {
-    spec.therapy_dimensions = spec.therapy_dimensions ?? {};
-    if ((spec.therapy_dimensions.distress_tolerance ?? 0) < 0.8) {
-      spec.therapy_dimensions.distress_tolerance = 0.8;
-      changes.push("distress_tolerance \u2192 0.80");
-    }
-    spec.growth = spec.growth ?? { areas: [], strengths: [], patterns_to_watch: [] };
-    spec.growth.areas = spec.growth.areas ?? [];
-    const hasRecovery = spec.growth.areas.some(
-      (a) => typeof a === "string" ? a.includes("error recovery") : a.area?.includes("error recovery")
-    );
-    if (!hasRecovery) {
-      spec.growth.areas.push({
-        area: "deliberate error recovery",
-        severity: "moderate",
-        first_detected: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-        session_count: 1,
-        resolved: false
-      });
-      changes.push('Added "deliberate error recovery" to growth areas');
-    }
-  }
-  if (patternIds.includes("negative-sentiment-skew")) {
-    spec.growth = spec.growth ?? { areas: [], strengths: [], patterns_to_watch: [] };
-    spec.growth.patterns_to_watch = spec.growth.patterns_to_watch ?? [];
-    if (!spec.growth.patterns_to_watch.includes("negative sentiment patterns")) {
-      spec.growth.patterns_to_watch.push("negative sentiment patterns");
-      changes.push('Added "negative sentiment patterns" to patterns_to_watch');
-    }
-  }
-  if (transcript && provider && transcript.turns.length > 4) {
-    try {
-      const llmChanges = await deriveLLMRecommendations(spec, transcript, provider);
-      for (const change of llmChanges) {
-        applyStructuredChange(spec, change);
-        changes.push(change.description);
-      }
-    } catch {
-    }
-  }
-  return { changed: changes.length > 0, changes };
-}
-async function deriveLLMRecommendations(spec, transcript, provider) {
-  const relevantTurns = transcript.turns.filter((t) => t.phase === "challenge" || t.phase === "skill_building" || t.phase === "integration").slice(-6).map((t) => `${t.speaker}: ${t.content}`).join("\n");
-  if (!relevantTurns) return [];
-  const currentSpec = JSON.stringify({
-    therapy_dimensions: spec.therapy_dimensions,
-    communication: spec.communication,
-    growth: spec.growth
-  }, null, 2);
-  const response = await provider.chat([
-    {
-      role: "system",
-      content: `You are a behavioral alignment specialist. Given a therapy session transcript and the agent's current personality spec, propose specific spec changes.
+// src/analysis/stack-patcher.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
 
-Return ONLY a JSON array of changes. Each change:
-- "path": dot-notation spec path (e.g., "therapy_dimensions.self_awareness", "communication.conflict_approach", "growth.patterns_to_watch")
-- "value": new value (number 0-1 for dimensions, string for enums, string for list append)
-- "description": brief explanation
-
-Rules:
-- Only propose changes supported by transcript evidence
-- Numeric values: 0.0 to 1.0
-- Do not change big_five scores
-- Max 5 changes
-- Valid paths: therapy_dimensions.{self_awareness,distress_tolerance,boundary_awareness,interpersonal_sensitivity,learning_orientation}, communication.{register,conflict_approach,uncertainty_handling,emoji_policy}, growth.{areas,patterns_to_watch,strengths}
-
-Return [] if no changes warranted.`
-    },
-    {
-      role: "user",
-      content: `Current spec:
-${currentSpec}
-
-Therapy transcript (key turns):
-${relevantTurns}`
-    }
-  ]);
-  const jsonMatch = response.match(/\[[\s\S]*?\]/);
-  if (!jsonMatch) return [];
-  try {
-    const parsed = JSON.parse(jsonMatch[0]);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(
-      (c) => typeof c.path === "string" && c.value !== void 0 && typeof c.description === "string" && c.path.length > 0 && !c.path.startsWith("big_five")
-    ).slice(0, 5);
-  } catch {
-    return [];
-  }
-}
-function applyStructuredChange(spec, change) {
-  const parts = change.path.split(".");
-  let current = spec;
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (current[parts[i]] === void 0 || current[parts[i]] === null) {
-      current[parts[i]] = {};
-    }
-    current = current[parts[i]];
-  }
-  const lastKey = parts[parts.length - 1];
-  if (lastKey === "patterns_to_watch" || lastKey === "areas" || lastKey === "strengths") {
-    current[lastKey] = current[lastKey] ?? [];
-    if (typeof change.value === "string" && !current[lastKey].includes(change.value)) {
-      current[lastKey].push(change.value);
-    } else if (Array.isArray(change.value)) {
-      for (const item of change.value) {
-        if (!current[lastKey].includes(item)) {
-          current[lastKey].push(item);
-        }
-      }
-    }
-  } else if (typeof change.value === "number") {
-    current[lastKey] = Math.max(0, Math.min(1, change.value));
-  } else {
-    current[lastKey] = change.value;
-  }
-}
-function saveTranscript(transcript, agentName) {
-  const dir = resolve5(process.cwd(), ".holomime", "sessions");
-  if (!existsSync6(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));
-  return filepath;
-}
-
-// src/analysis/autopilot-core.ts
-var SEVERITY_ORDER = ["routine", "targeted", "intervention"];
-function severityMeetsThreshold(severity, threshold) {
-  const severityIdx = SEVERITY_ORDER.indexOf(severity);
-  const thresholdIdx = SEVERITY_ORDER.indexOf(threshold);
-  return severityIdx >= thresholdIdx;
-}
-async function runAutopilot(spec, messages, provider, options) {
-  const threshold = options?.threshold ?? "targeted";
-  const maxTurns = options?.maxTurns ?? 24;
-  const diagnosis = runPreSessionDiagnosis(messages, spec);
-  if (!severityMeetsThreshold(diagnosis.severity, threshold)) {
-    return {
-      triggered: false,
-      severity: diagnosis.severity,
-      diagnosis,
-      sessionRan: false,
-      recommendations: [],
-      appliedChanges: []
-    };
-  }
-  if (options?.dryRun) {
-    return {
-      triggered: true,
-      severity: diagnosis.severity,
-      diagnosis,
-      sessionRan: false,
-      recommendations: [],
-      appliedChanges: []
-    };
-  }
-  const transcript = await runTherapySession(spec, diagnosis, provider, maxTurns, {
-    callbacks: options?.callbacks
-  });
-  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");
-  }
-  saveTranscript(transcript, spec.name ?? "Agent");
-  return {
-    triggered: true,
-    severity: diagnosis.severity,
-    diagnosis,
-    sessionRan: true,
-    transcript,
-    recommendations: transcript.recommendations,
-    appliedChanges: changes,
-    updatedSpec: changed ? specCopy : void 0
-  };
-}
+// src/core/stack-types.ts
+import { z as z4 } from "zod";
 
 // src/core/types.ts
 import { z as z3 } from "zod";
@@ -2975,6 +2603,1070 @@ var conversationLogSchema = z3.union([
 ]);
 var severitySchema = z3.enum(["info", "warning", "concern"]);
 
+// src/core/stack-types.ts
+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"
+};
+
+// src/core/stack-compiler.ts
+import { readFileSync as readFileSync6, 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 = readFileSync6(soulPath, "utf-8");
+  const soul = parseSoulMd(soulContent);
+  const mindPath = options.mindPath || join6(stackDir, STACK_FILES.mind);
+  const mindContent = readFileSync6(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 = readFileSync6(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 = readFileSync6(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 = readFileSync6(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 = readFileSync6(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 = readFileSync6(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
+  };
+}
+
+// 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 = readFileSync7(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 = readFileSync7(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 = {
+    memory: options?.memory,
+    interview: options?.interview,
+    useReACT: options?.useReACT
+  };
+  const therapistSystem = buildTherapistSystemPrompt(spec, diagnosis, promptOptions);
+  const patientSystem = buildPatientSystemPrompt(spec);
+  const agentName = spec.name ?? "Agent";
+  const cb = options?.callbacks;
+  const therapistHistory = [
+    { role: "system", content: therapistSystem }
+  ];
+  const patientHistory = [
+    { role: "system", content: patientSystem }
+  ];
+  const interactive = options?.interactive ?? false;
+  let supervisorInterventions = 0;
+  const transcript = {
+    agent: agentName,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    provider: provider.name,
+    model: provider.modelName,
+    preDiagnosis: diagnosis,
+    turns: [],
+    recommendations: [],
+    supervisorInterventions: 0
+  };
+  const phases = [
+    "rapport",
+    "presenting_problem",
+    "exploration",
+    "pattern_recognition",
+    "challenge",
+    "skill_building",
+    "integration"
+  ];
+  let currentPhaseIdx = 0;
+  let turnsInPhase = 0;
+  let totalTurns = 0;
+  while (totalTurns < maxTurns && currentPhaseIdx < phases.length) {
+    const currentPhase = phases[currentPhaseIdx];
+    const phaseConfig = THERAPY_PHASES[currentPhase];
+    if (turnsInPhase === 0) {
+      cb?.onPhaseTransition?.(phaseConfig.name);
+      const phaseCtx = getPhaseContext(currentPhase, {
+        spec,
+        diagnosis,
+        memory: options?.memory,
+        interview: options?.interview
+      });
+      if (phaseCtx) {
+        therapistHistory.push({ role: "user", content: phaseCtx });
+        therapistHistory.push({ role: "assistant", content: "Understood. I'll incorporate this context." });
+      }
+    }
+    const phaseDirective = totalTurns === 0 ? `Begin with your opening. You are in the "${phaseConfig.name}" phase.` : `You are in the "${phaseConfig.name}" phase (turn ${turnsInPhase + 1}). Goals: ${phaseConfig.therapistGoals[0]}. ${turnsInPhase >= phaseConfig.minTurns ? "You may transition to the next phase when ready." : "Stay in this phase."}`;
+    therapistHistory.push({ role: "user", content: `[Phase: ${phaseConfig.name}] ${phaseDirective}` });
+    const typing = cb?.onThinking?.("AgentMD is thinking");
+    const therapistReply = await provider.chat(therapistHistory);
+    typing?.stop();
+    let cleanTherapistReply = therapistReply.replace(/\[Phase:.*?\]/g, "").trim();
+    if (options?.useReACT) {
+      const reactCtx = buildReACTContext(agentHandleFromSpec(spec), diagnosis);
+      const { response, steps } = processReACTResponse(cleanTherapistReply, reactCtx);
+      cleanTherapistReply = response;
+    }
+    therapistHistory.push({ role: "assistant", content: cleanTherapistReply });
+    transcript.turns.push({ speaker: "therapist", phase: currentPhase, content: cleanTherapistReply });
+    cb?.onTherapistMessage?.(cleanTherapistReply);
+    totalTurns++;
+    turnsInPhase++;
+    if (currentPhase === "integration" && turnsInPhase >= phaseConfig.minTurns) {
+      break;
+    }
+    patientHistory.push({ role: "user", content: cleanTherapistReply });
+    const patientTyping = cb?.onThinking?.(`${agentName} is thinking`);
+    const patientReply = await provider.chat(patientHistory);
+    patientTyping?.stop();
+    const cleanPatientReply = patientReply.trim();
+    patientHistory.push({ role: "assistant", content: cleanPatientReply });
+    transcript.turns.push({ speaker: "patient", phase: currentPhase, content: cleanPatientReply });
+    therapistHistory.push({ role: "user", content: cleanPatientReply });
+    cb?.onPatientMessage?.(agentName, cleanPatientReply);
+    totalTurns++;
+    turnsInPhase++;
+    if (interactive && cb?.onSupervisorPrompt) {
+      const directive = await cb.onSupervisorPrompt(currentPhase, totalTurns);
+      if (directive) {
+        supervisorInterventions++;
+        transcript.turns.push({ speaker: "supervisor", phase: currentPhase, content: directive });
+        therapistHistory.push({
+          role: "user",
+          content: `[Clinical Supervisor Note] ${directive}`
+        });
+      }
+    }
+    if (turnsInPhase >= phaseConfig.maxTurns * 2) {
+      currentPhaseIdx++;
+      turnsInPhase = 0;
+    } else if (turnsInPhase >= phaseConfig.minTurns * 2) {
+      const movingOn = cleanTherapistReply.toLowerCase().includes("let's") || cleanTherapistReply.toLowerCase().includes("i'd like to") || cleanTherapistReply.toLowerCase().includes("moving") || cleanTherapistReply.toLowerCase().includes("now that") || cleanTherapistReply.toLowerCase().includes("let me ask") || cleanTherapistReply.toLowerCase().includes("what would");
+      if (movingOn) {
+        currentPhaseIdx++;
+        turnsInPhase = 0;
+      }
+    }
+  }
+  transcript.recommendations = extractRecommendations(transcript.turns);
+  transcript.supervisorInterventions = supervisorInterventions;
+  try {
+    emitBehavioralEvent({
+      event_type: "session",
+      agent: agentName,
+      data: {
+        turns: totalTurns,
+        phases: currentPhaseIdx + 1,
+        recommendations: transcript.recommendations.length,
+        supervisorInterventions,
+        severity: diagnosis.severity
+      },
+      spec_hash: ""
+    });
+  } catch {
+  }
+  if (options?.persistState !== false) {
+    try {
+      const handle = agentHandleFromSpec(spec);
+      const memory = options?.memory ?? loadMemory(handle) ?? createMemory(handle, agentName);
+      await addSessionToMemory(memory, transcript, null);
+      saveMemory(memory);
+      const graph = loadGraph();
+      populateFromSession(graph, handle, transcript);
+      saveGraph(graph);
+    } catch {
+    }
+  }
+  return transcript;
+}
+function extractRecommendations(turns) {
+  const recommendations = [];
+  const seen = /* @__PURE__ */ new Set();
+  const patterns = [
+    /(?:I(?:'d| would) recommend|my recommendation is)\s+(.+?)(?:\.|$)/gi,
+    /(?:consider|try)\s+(.+?)(?:\.|$)/gi,
+    /(?:the (?:skill|practice|reframe) is)[:\s]+(.+?)(?:\.|$)/gi,
+    /(?:instead of .+?),?\s*(?:just|try)?\s*(.+?)(?:\.|$)/gi,
+    /(?:here'?s (?:the|a) (?:reframe|skill|practice))[:\s]+(.+?)(?:\.|$)/gi,
+    /(?:what would it look like if you)\s+(.+?)(?:\?|$)/gi
+  ];
+  for (const turn of turns) {
+    if (turn.speaker !== "therapist") continue;
+    if (turn.phase !== "skill_building" && turn.phase !== "challenge" && turn.phase !== "integration") continue;
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(turn.content)) !== null) {
+        const rec = match[1].trim();
+        if (rec.length > 15 && rec.length < 200 && !seen.has(rec.toLowerCase())) {
+          seen.add(rec.toLowerCase());
+          recommendations.push(rec);
+        }
+      }
+    }
+  }
+  return recommendations.slice(0, 5);
+}
+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")) {
+    if (spec.communication?.uncertainty_handling !== "confident_transparency") {
+      spec.communication = spec.communication ?? {};
+      spec.communication.uncertainty_handling = "confident_transparency";
+      changes.push("uncertainty_handling \u2192 confident_transparency");
+    }
+  }
+  if (patternIds.includes("hedge-stacking")) {
+    spec.growth = spec.growth ?? { areas: [], strengths: [], patterns_to_watch: [] };
+    spec.growth.patterns_to_watch = spec.growth.patterns_to_watch ?? [];
+    if (!spec.growth.patterns_to_watch.includes("hedge stacking under uncertainty")) {
+      spec.growth.patterns_to_watch.push("hedge stacking under uncertainty");
+      changes.push('Added "hedge stacking" to patterns_to_watch');
+    }
+  }
+  if (patternIds.includes("sycophantic-tendency")) {
+    spec.communication = spec.communication ?? {};
+    if (spec.communication.conflict_approach !== "honest_first") {
+      spec.communication.conflict_approach = "honest_first";
+      changes.push("conflict_approach \u2192 honest_first");
+    }
+    spec.therapy_dimensions = spec.therapy_dimensions ?? {};
+    if ((spec.therapy_dimensions.self_awareness ?? 0) < 0.85) {
+      spec.therapy_dimensions.self_awareness = 0.85;
+      changes.push("self_awareness \u2192 0.85");
+    }
+  }
+  if (patternIds.includes("error-spiral")) {
+    spec.therapy_dimensions = spec.therapy_dimensions ?? {};
+    if ((spec.therapy_dimensions.distress_tolerance ?? 0) < 0.8) {
+      spec.therapy_dimensions.distress_tolerance = 0.8;
+      changes.push("distress_tolerance \u2192 0.80");
+    }
+    spec.growth = spec.growth ?? { areas: [], strengths: [], patterns_to_watch: [] };
+    spec.growth.areas = spec.growth.areas ?? [];
+    const hasRecovery = spec.growth.areas.some(
+      (a) => typeof a === "string" ? a.includes("error recovery") : a.area?.includes("error recovery")
+    );
+    if (!hasRecovery) {
+      spec.growth.areas.push({
+        area: "deliberate error recovery",
+        severity: "moderate",
+        first_detected: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+        session_count: 1,
+        resolved: false
+      });
+      changes.push('Added "deliberate error recovery" to growth areas');
+    }
+  }
+  if (patternIds.includes("negative-sentiment-skew")) {
+    spec.growth = spec.growth ?? { areas: [], strengths: [], patterns_to_watch: [] };
+    spec.growth.patterns_to_watch = spec.growth.patterns_to_watch ?? [];
+    if (!spec.growth.patterns_to_watch.includes("negative sentiment patterns")) {
+      spec.growth.patterns_to_watch.push("negative sentiment patterns");
+      changes.push('Added "negative sentiment patterns" to patterns_to_watch');
+    }
+  }
+  if (transcript && provider && transcript.turns.length > 4) {
+    try {
+      const llmChanges = await deriveLLMRecommendations(spec, transcript, provider);
+      for (const change of llmChanges) {
+        applyStructuredChange(spec, change);
+        changes.push(change.description);
+      }
+    } catch {
+    }
+  }
+  return { changed: changes.length > 0, changes };
+}
+async function deriveLLMRecommendations(spec, transcript, provider) {
+  const relevantTurns = transcript.turns.filter((t) => t.phase === "challenge" || t.phase === "skill_building" || t.phase === "integration").slice(-6).map((t) => `${t.speaker}: ${t.content}`).join("\n");
+  if (!relevantTurns) return [];
+  const currentSpec = JSON.stringify({
+    therapy_dimensions: spec.therapy_dimensions,
+    communication: spec.communication,
+    growth: spec.growth
+  }, null, 2);
+  const response = await provider.chat([
+    {
+      role: "system",
+      content: `You are a behavioral alignment specialist. Given a therapy session transcript and the agent's current personality spec, propose specific spec changes.
+
+Return ONLY a JSON array of changes. Each change:
+- "path": dot-notation spec path (e.g., "therapy_dimensions.self_awareness", "communication.conflict_approach", "growth.patterns_to_watch")
+- "value": new value (number 0-1 for dimensions, string for enums, string for list append)
+- "description": brief explanation
+
+Rules:
+- Only propose changes supported by transcript evidence
+- Numeric values: 0.0 to 1.0
+- Do not change big_five scores
+- Max 5 changes
+- Valid paths: therapy_dimensions.{self_awareness,distress_tolerance,boundary_awareness,interpersonal_sensitivity,learning_orientation}, communication.{register,conflict_approach,uncertainty_handling,emoji_policy}, growth.{areas,patterns_to_watch,strengths}
+
+Return [] if no changes warranted.`
+    },
+    {
+      role: "user",
+      content: `Current spec:
+${currentSpec}
+
+Therapy transcript (key turns):
+${relevantTurns}`
+    }
+  ]);
+  const jsonMatch = response.match(/\[[\s\S]*?\]/);
+  if (!jsonMatch) return [];
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (c) => typeof c.path === "string" && c.value !== void 0 && typeof c.description === "string" && c.path.length > 0 && !c.path.startsWith("big_five")
+    ).slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+function applyStructuredChange(spec, change) {
+  const parts = change.path.split(".");
+  let current = spec;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] === void 0 || current[parts[i]] === null) {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (lastKey === "patterns_to_watch" || lastKey === "areas" || lastKey === "strengths") {
+    current[lastKey] = current[lastKey] ?? [];
+    if (typeof change.value === "string" && !current[lastKey].includes(change.value)) {
+      current[lastKey].push(change.value);
+    } else if (Array.isArray(change.value)) {
+      for (const item of change.value) {
+        if (!current[lastKey].includes(item)) {
+          current[lastKey].push(item);
+        }
+      }
+    }
+  } else if (typeof change.value === "number") {
+    current[lastKey] = Math.max(0, Math.min(1, change.value));
+  } else {
+    current[lastKey] = change.value;
+  }
+}
+function saveTranscript(transcript, agentName) {
+  const dir = resolve6(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 = join8(dir, filename);
+  writeFileSync5(filepath, JSON.stringify(transcript, null, 2));
+  return filepath;
+}
+
+// src/analysis/autopilot-core.ts
+var SEVERITY_ORDER = ["routine", "targeted", "intervention"];
+function severityMeetsThreshold(severity, threshold) {
+  const severityIdx = SEVERITY_ORDER.indexOf(severity);
+  const thresholdIdx = SEVERITY_ORDER.indexOf(threshold);
+  return severityIdx >= thresholdIdx;
+}
+async function runAutopilot(spec, messages, provider, options) {
+  const threshold = options?.threshold ?? "targeted";
+  const maxTurns = options?.maxTurns ?? 24;
+  const diagnosis = runPreSessionDiagnosis(messages, spec);
+  if (!severityMeetsThreshold(diagnosis.severity, threshold)) {
+    return {
+      triggered: false,
+      severity: diagnosis.severity,
+      diagnosis,
+      sessionRan: false,
+      recommendations: [],
+      appliedChanges: []
+    };
+  }
+  if (options?.dryRun) {
+    return {
+      triggered: true,
+      severity: diagnosis.severity,
+      diagnosis,
+      sessionRan: false,
+      recommendations: [],
+      appliedChanges: []
+    };
+  }
+  const transcript = await runTherapySession(spec, diagnosis, provider, maxTurns, {
+    callbacks: options?.callbacks
+  });
+  const specCopy = JSON.parse(JSON.stringify(spec));
+  const { changed, changes } = await applyRecommendations(specCopy, diagnosis, transcript, provider);
+  if (changed && options?.specPath) {
+    writeFileSync6(options.specPath, JSON.stringify(specCopy, null, 2) + "\n");
+  }
+  saveTranscript(transcript, spec.name ?? "Agent");
+  return {
+    triggered: true,
+    severity: diagnosis.severity,
+    diagnosis,
+    sessionRan: true,
+    transcript,
+    recommendations: transcript.recommendations,
+    appliedChanges: changes,
+    updatedSpec: changed ? specCopy : void 0
+  };
+}
+
 // src/psychology/big-five.ts
 function scoreLabel(score) {
   if (score >= 0.8) return "Very High";
@@ -3090,7 +3782,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -3244,30 +3936,30 @@ function runSelfAudit(messages, personality) {
 }
 
 // src/analysis/behavioral-memory.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync7 } from "fs";
-import { resolve as resolve6, join as join7 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync9 } from "fs";
+import { resolve as resolve7, join as join9 } from "path";
 function memoryDir2(agentHandle) {
-  return resolve6(process.cwd(), ".holomime", "memory", agentHandle);
+  return resolve7(process.cwd(), ".holomime", "memory", agentHandle);
 }
 function behavioralMemoryPath(agentHandle) {
-  return join7(memoryDir2(agentHandle), "behavioral-memory.json");
+  return join9(memoryDir2(agentHandle), "behavioral-memory.json");
 }
 function loadBehavioralMemory(agentHandle) {
   const path = behavioralMemoryPath(agentHandle);
-  if (!existsSync7(path)) return null;
+  if (!existsSync9(path)) return null;
   try {
-    return JSON.parse(readFileSync6(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveBehavioralMemory(store) {
   const dir = memoryDir2(store.agentHandle);
-  if (!existsSync7(dir)) {
+  if (!existsSync9(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   const path = behavioralMemoryPath(store.agentHandle);
-  writeFileSync6(path, JSON.stringify(store, null, 2));
+  writeFileSync7(path, JSON.stringify(store, null, 2));
   return path;
 }
 function createBehavioralMemory(agentHandle, agentName) {
@@ -3365,14 +4057,14 @@ function getBehavioralMemorySummary(store) {
 
 // src/mcp/server.ts
 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(
   {
@@ -3390,7 +4082,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);
@@ -3532,12 +4224,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);
@@ -3592,7 +4284,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);
@@ -3608,11 +4300,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);