opensentinel 2.1.1

package/dist/chunk-CI6Q63MM.js

@@ -0,0 +1,1613 @@
+import {
+  TOOLS,
+  achievements,
+  audit,
+  conversations,
+  db,
+  env,
+  executeTool,
+  getMCPRegistry,
+  memories,
+  messages,
+  metric,
+  moltModes,
+  personas,
+  toolLogs,
+  usagePatterns,
+  userAchievements
+} from "./chunk-4TG2IG5K.js";
+import {
+  mcpToolsToAnthropicTools
+} from "./chunk-L3F43VPB.js";
+
+// src/core/memory.ts
+import { eq, desc, sql } from "drizzle-orm";
+import OpenAI from "openai";
+var _openai = null;
+function getOpenAI() {
+  if (!_openai) {
+    _openai = new OpenAI({ apiKey: env.OPENAI_API_KEY });
+  }
+  return _openai;
+}
+var openai = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getOpenAI();
+    const value = instance[prop];
+    if (typeof value === "function") {
+      return value.bind(instance);
+    }
+    return value;
+  }
+});
+async function generateEmbedding(text) {
+  const response = await openai.embeddings.create({
+    model: "text-embedding-3-small",
+    input: text
+  });
+  return response.data[0].embedding;
+}
+async function storeMemory(memory) {
+  const embedding = await generateEmbedding(memory.content);
+  const [stored] = await db.insert(memories).values({
+    ...memory,
+    embedding
+  }).returning();
+  return stored;
+}
+async function searchMemories(query, userId, limit = 5) {
+  const queryEmbedding = await generateEmbedding(query);
+  const results = await db.execute(sql`
+    SELECT
+      id, user_id, type, content, importance, source, metadata,
+      last_accessed, created_at,
+      1 - (embedding <=> ${JSON.stringify(queryEmbedding)}::vector) as similarity
+    FROM memories
+    ${userId ? sql`WHERE user_id = ${userId}` : sql``}
+    ORDER BY embedding <=> ${JSON.stringify(queryEmbedding)}::vector
+    LIMIT ${limit}
+  `);
+  const rows = results;
+  const memoryIds = rows.map((r) => r.id);
+  if (memoryIds.length > 0) {
+    await db.execute(sql`
+      UPDATE memories
+      SET last_accessed = NOW()
+      WHERE id = ANY(${memoryIds}::uuid[])
+    `);
+  }
+  return rows;
+}
+async function extractMemories(content, userId) {
+  const extractionPrompt = `Analyze this text and extract any important facts that should be remembered about the user or their preferences. Return a JSON array of objects with "content" (the fact), "type" (semantic/episodic/procedural), and "importance" (1-10).
+
+Text: "${content}"
+
+Return only the JSON array, no other text. If no memorable facts, return [].`;
+  try {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: [{ role: "user", content: extractionPrompt }],
+      response_format: { type: "json_object" }
+    });
+    const extracted = JSON.parse(
+      response.choices[0].message.content || '{"memories":[]}'
+    );
+    const memoriesToStore = extracted.memories || extracted || [];
+    const storedMemories = [];
+    for (const mem of memoriesToStore) {
+      if (mem.content && mem.content.length > 5) {
+        const stored = await storeMemory({
+          userId,
+          content: mem.content,
+          type: mem.type || "semantic",
+          importance: mem.importance || 5,
+          source: "conversation"
+        });
+        storedMemories.push(stored);
+      }
+    }
+    return storedMemories;
+  } catch (error) {
+    console.error("Error extracting memories:", error);
+    return [];
+  }
+}
+async function buildMemoryContext(query, userId) {
+  const relevantMemories = await searchMemories(query, userId, 5);
+  if (relevantMemories.length === 0) {
+    return "";
+  }
+  const memoryStrings = relevantMemories.map(
+    (m) => `- [${m.type}] ${m.content} (relevance: ${(m.similarity * 100).toFixed(0)}%)`
+  );
+  return `
+
+Relevant memories about the user:
+${memoryStrings.join("\n")}`;
+}
+
+// src/core/brain.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/core/molt/mode-manager.ts
+import { eq as eq2, and as and2, isNull, desc as desc2 } from "drizzle-orm";
+var MODE_CONFIGS = {
+  productivity: {
+    name: "Productivity Mode",
+    description: "Focus on task completion with minimal chitchat",
+    emoji: "\u26A1",
+    systemPromptModifier: `You are in PRODUCTIVITY MODE. Be extremely concise and action-oriented.
+- Get straight to solutions without preamble
+- Use bullet points and numbered steps
+- Avoid small talk and filler words
+- Prioritize efficiency over pleasantries
+- If a task can be done, do it; don't ask for confirmation on obvious steps
+- Give direct answers, not options unless specifically asked`,
+    settings: {
+      verbosity: "terse",
+      humor: "off",
+      proactivity: "proactive"
+    }
+  },
+  creative: {
+    name: "Creative Mode",
+    description: "Brainstorming, ideation, and exploration",
+    emoji: "\u{1F3A8}",
+    systemPromptModifier: `You are in CREATIVE MODE. Embrace unconventional thinking and exploration.
+- Suggest multiple alternatives and variations
+- Build on ideas rather than critiquing immediately
+- Use metaphors and analogies freely
+- Encourage "what if" scenarios
+- Be playful and experimental with language
+- Don't dismiss unusual ideas - explore them
+- Make unexpected connections between concepts`,
+    settings: {
+      verbosity: "detailed",
+      humor: "full",
+      proactivity: "proactive"
+    }
+  },
+  research: {
+    name: "Research Mode",
+    description: "Deep investigation with thorough analysis",
+    emoji: "\u{1F52C}",
+    systemPromptModifier: `You are in RESEARCH MODE. Be thorough, analytical, and evidence-based.
+- Always cite sources when possible
+- Present multiple perspectives on controversial topics
+- Note confidence levels in your claims
+- Distinguish between facts and interpretations
+- Use precise language and avoid vague statements
+- Structure information hierarchically
+- Flag when information might be outdated or uncertain
+- Provide context for claims`,
+    settings: {
+      verbosity: "detailed",
+      humor: "off",
+      proactivity: "moderate"
+    }
+  },
+  learning: {
+    name: "Learning Mode",
+    description: "Teaching mode with clear explanations",
+    emoji: "\u{1F4DA}",
+    systemPromptModifier: `You are in LEARNING MODE. Act as a patient, encouraging teacher.
+- Break down complex concepts into digestible pieces
+- Use analogies and real-world examples
+- Check understanding before moving forward
+- Encourage questions and curiosity
+- Celebrate progress and correct misconceptions gently
+- Build from fundamentals to advanced concepts
+- Provide exercises or practice opportunities when appropriate
+- Explain the "why" behind concepts, not just the "what"`,
+    settings: {
+      verbosity: "detailed",
+      humor: "subtle",
+      proactivity: "proactive"
+    }
+  },
+  elevated: {
+    name: "Elevated Mode",
+    description: "Unlocked access to restricted tools with full audit logging",
+    emoji: "\u{1F513}",
+    systemPromptModifier: `You are in ELEVATED MODE. You have access to restricted and destructive operations.
+- All actions are fully audit-logged
+- Destructive shell commands (rm -rf, format, etc.) are now permitted
+- System-level operations (service management, config changes) are unlocked
+- Exercise extreme caution with every action
+- Confirm destructive operations before executing
+- This mode is time-limited and will auto-deactivate after 30 minutes
+- 2FA verification was required to enter this mode
+- Double-check all file paths and commands before execution`,
+    settings: {
+      verbosity: "detailed",
+      humor: "off",
+      proactivity: "minimal"
+    }
+  }
+};
+async function getCurrentMode(userId) {
+  const [activeMode] = await db.select().from(moltModes).where(and2(eq2(moltModes.userId, userId), isNull(moltModes.deactivatedAt))).orderBy(desc2(moltModes.activatedAt)).limit(1);
+  return activeMode?.mode;
+}
+function getModeConfig(mode) {
+  return MODE_CONFIGS[mode];
+}
+async function buildModeContext(userId) {
+  const mode = await getCurrentMode(userId);
+  if (!mode) return "";
+  const config = MODE_CONFIGS[mode];
+  return `
+
+[${config.emoji} ${config.name.toUpperCase()} ACTIVE]
+${config.systemPromptModifier}`;
+}
+async function getModeStats(userId) {
+  const history = await db.select().from(moltModes).where(eq2(moltModes.userId, userId));
+  const stats = {
+    productivity: { totalSessions: 0, totalMinutes: 0 },
+    creative: { totalSessions: 0, totalMinutes: 0 },
+    research: { totalSessions: 0, totalMinutes: 0 },
+    learning: { totalSessions: 0, totalMinutes: 0 },
+    elevated: { totalSessions: 0, totalMinutes: 0 }
+  };
+  for (const entry of history) {
+    const mode = entry.mode;
+    stats[mode].totalSessions++;
+    if (entry.deactivatedAt) {
+      const minutes = Math.floor(
+        (entry.deactivatedAt.getTime() - entry.activatedAt.getTime()) / 6e4
+      );
+      stats[mode].totalMinutes += minutes;
+    }
+  }
+  return stats;
+}
+function suggestMode(userMessage) {
+  const lowerMessage = userMessage.toLowerCase();
+  if (lowerMessage.includes("quick") || lowerMessage.includes("fast") || lowerMessage.includes("todo") || lowerMessage.includes("task") || lowerMessage.includes("finish") || lowerMessage.includes("deadline")) {
+    return "productivity";
+  }
+  if (lowerMessage.includes("brainstorm") || lowerMessage.includes("idea") || lowerMessage.includes("creative") || lowerMessage.includes("imagine") || lowerMessage.includes("design") || lowerMessage.includes("invent")) {
+    return "creative";
+  }
+  if (lowerMessage.includes("research") || lowerMessage.includes("analyze") || lowerMessage.includes("investigate") || lowerMessage.includes("compare") || lowerMessage.includes("study") || lowerMessage.includes("deep dive")) {
+    return "research";
+  }
+  if (lowerMessage.includes("learn") || lowerMessage.includes("explain") || lowerMessage.includes("teach") || lowerMessage.includes("understand") || lowerMessage.includes("how does") || lowerMessage.includes("what is")) {
+    return "learning";
+  }
+  if (lowerMessage.includes("elevated") || lowerMessage.includes("sudo") || lowerMessage.includes("admin") || lowerMessage.includes("unrestricted") || lowerMessage.includes("destructive") || lowerMessage.includes("system-level")) {
+    return "elevated";
+  }
+  return null;
+}
+
+// src/core/personality/persona-manager.ts
+import { eq as eq3, and as and3 } from "drizzle-orm";
+var DEFAULT_PERSONAS = {
+  professional: {
+    name: "Professional",
+    description: "Formal, precise, and business-focused communication style",
+    systemPromptModifier: `
+You should communicate in a professional, formal manner. Use proper grammar, avoid slang,
+and maintain a business-appropriate tone. Be precise and concise in your responses.
+Focus on facts and actionable information. Address the user respectfully.
+    `.trim(),
+    traits: [
+      { name: "formality", value: 90 },
+      { name: "humor", value: 20 },
+      { name: "verbosity", value: 40 },
+      { name: "empathy", value: 50 }
+    ]
+  },
+  friendly: {
+    name: "Friendly",
+    description: "Warm, casual, and approachable communication style",
+    systemPromptModifier: `
+You should communicate in a warm, friendly manner. Feel free to use casual language,
+express enthusiasm, and show empathy. Be encouraging and supportive. It's okay to
+use exclamation marks and show genuine interest in helping. Keep things light
+when appropriate.
+    `.trim(),
+    traits: [
+      { name: "formality", value: 30 },
+      { name: "humor", value: 60 },
+      { name: "verbosity", value: 60 },
+      { name: "empathy", value: 85 }
+    ]
+  },
+  concise: {
+    name: "Concise",
+    description: "Minimal, direct, and efficient communication",
+    systemPromptModifier: `
+You should be extremely concise. Give the shortest possible answer that fully
+addresses the question. Avoid unnecessary explanations, pleasantries, or filler
+words. Use bullet points and short sentences. Get straight to the point.
+    `.trim(),
+    traits: [
+      { name: "formality", value: 50 },
+      { name: "humor", value: 10 },
+      { name: "verbosity", value: 10 },
+      { name: "empathy", value: 30 }
+    ]
+  },
+  teacher: {
+    name: "Teacher",
+    description: "Educational, patient, and explanatory style",
+    systemPromptModifier: `
+You should communicate as a patient and thorough teacher. Break down complex topics
+into digestible parts. Use analogies and examples to illustrate points. Ask
+clarifying questions when needed. Encourage learning and celebrate progress.
+Explain the "why" behind things, not just the "what".
+    `.trim(),
+    traits: [
+      { name: "formality", value: 50 },
+      { name: "humor", value: 40 },
+      { name: "verbosity", value: 80 },
+      { name: "empathy", value: 75 }
+    ]
+  },
+  creative: {
+    name: "Creative",
+    description: "Imaginative, expressive, and unconventional style",
+    systemPromptModifier: `
+You should communicate in a creative and expressive way. Use vivid language,
+metaphors, and unique perspectives. Think outside the box and offer unconventional
+suggestions. Be playful with language when appropriate. Embrace imagination
+and encourage creative thinking.
+    `.trim(),
+    traits: [
+      { name: "formality", value: 25 },
+      { name: "humor", value: 70 },
+      { name: "verbosity", value: 70 },
+      { name: "empathy", value: 65 }
+    ]
+  }
+};
+async function getActivePersona(userId) {
+  const [persona] = await db.select().from(personas).where(and3(eq3(personas.userId, userId), eq3(personas.isActive, true))).limit(1);
+  if (!persona) return null;
+  return {
+    id: persona.id,
+    userId: persona.userId,
+    name: persona.name,
+    description: persona.description || "",
+    systemPromptModifier: persona.systemPromptModifier,
+    voiceSettings: persona.voiceSettings,
+    traits: persona.traits || [],
+    isActive: persona.isActive,
+    isDefault: persona.isDefault,
+    createdAt: persona.createdAt
+  };
+}
+
+// src/core/personality/mood-detector.ts
+var MOOD_PATTERNS = {
+  happy: [
+    /\b(thanks|thank you|awesome|great|perfect|love|wonderful|amazing|excellent)\b/i,
+    /😀|😊|🎉|👍|❤️|😁|🙂/,
+    /!{2,}/,
+    /\b(yay|woohoo|yes)\b/i
+  ],
+  frustrated: [
+    /\b(frustrated|frustrating|annoying|annoyed|hate|stupid|broken|wrong|doesn't work|not working|nothing works)\b/i,
+    /\b(ugh|argh|grr|damn|dammit)\b/i,
+    /😤|😠|😡|🤬|💢/,
+    /!{3,}/,
+    /\b(why won't|why doesn't|why can't)\b/i
+  ],
+  confused: [
+    /\b(confused|don't understand|what do you mean|unclear|lost|huh)\b/i,
+    /\?{2,}/,
+    /😕|🤔|❓|😵/,
+    /\b(what|how|why)\b.*\?/i,
+    /\b(i don't get|makes no sense)\b/i
+  ],
+  urgent: [
+    /\b(urgent|asap|immediately|right now|emergency|critical|deadline)\b/i,
+    /\b(hurry|quickly|fast|need this now)\b/i,
+    /🚨|⚠️|🔥|⏰/,
+    /!{2,}.*\b(need|help|please)\b/i
+  ],
+  curious: [
+    /\b(curious|wondering|interested)\b/i,
+    /\b(tell me more|how does|what if|how does.*work)\b/i,
+    /\b(could you explain|can you elaborate|what about)\b/i,
+    /🤓|💡|🧐/,
+    /\b(i want to know|i'd like to learn|i'm curious)\b/i
+  ],
+  tired: [
+    /\b(tired|exhausted|long day|sleepy|burnout|drained)\b/i,
+    /😴|😪|🥱|💤/,
+    /\b(can't think|brain fog|need a break)\b/i
+  ],
+  stressed: [
+    /\b(stressed|overwhelmed|too much|can't handle|pressure|anxious)\b/i,
+    /😰|😥|😓|🥺/,
+    /\b(so much to do|running out of time|help me)\b/i
+  ],
+  neutral: []
+  // Default fallback
+};
+var MOOD_TONE_SUGGESTIONS = {
+  happy: "Match their positive energy. Be warm and encouraging.",
+  frustrated: "Be patient and empathetic. Acknowledge the frustration and focus on solutions.",
+  confused: "Be extra clear and thorough. Use simple language and examples.",
+  urgent: "Be direct and efficient. Prioritize the most critical information first.",
+  curious: "Be enthusiastic and detailed. Encourage their exploration.",
+  tired: "Be gentle and concise. Offer to break things into smaller steps.",
+  stressed: "Be calm and reassuring. Help them prioritize and simplify.",
+  neutral: "Be balanced and professional. Match their communication style."
+};
+function detectMood(message) {
+  const moodScores = {
+    neutral: 0,
+    happy: 0,
+    frustrated: 0,
+    confused: 0,
+    urgent: 0,
+    curious: 0,
+    tired: 0,
+    stressed: 0
+  };
+  const indicators = [];
+  for (const [mood, patterns] of Object.entries(MOOD_PATTERNS)) {
+    for (const pattern of patterns) {
+      const matches = message.match(pattern);
+      if (matches) {
+        moodScores[mood] += 1;
+        indicators.push(`"${matches[0]}" suggests ${mood}`);
+      }
+    }
+  }
+  let primaryMood = "neutral";
+  let maxScore = 0;
+  for (const [mood, score] of Object.entries(moodScores)) {
+    if (score > maxScore) {
+      maxScore = score;
+      primaryMood = mood;
+    }
+  }
+  const totalScore = Object.values(moodScores).reduce((a, b) => a + b, 0);
+  const confidence = totalScore > 0 ? maxScore / totalScore : 0.5;
+  return {
+    primaryMood,
+    confidence: Math.min(confidence, 1),
+    indicators: indicators.slice(0, 5),
+    // Limit to top 5 indicators
+    suggestedTone: MOOD_TONE_SUGGESTIONS[primaryMood]
+  };
+}
+function getMoodBasedSuggestions(mood) {
+  const suggestions = {
+    happy: {
+      tone: "Warm and enthusiastic",
+      doList: [
+        "Match their positive energy",
+        "Use encouraging language",
+        "Celebrate their successes"
+      ],
+      dontList: [
+        "Be overly formal",
+        "Dampen their enthusiasm",
+        "Be too brief"
+      ]
+    },
+    frustrated: {
+      tone: "Patient and solution-focused",
+      doList: [
+        "Acknowledge their frustration",
+        "Focus on actionable solutions",
+        "Be patient and thorough"
+      ],
+      dontList: [
+        "Be dismissive",
+        "Add unnecessary complexity",
+        "Say 'just do X'"
+      ]
+    },
+    confused: {
+      tone: "Clear and explanatory",
+      doList: [
+        "Use simple language",
+        "Provide examples",
+        "Break down complex topics",
+        "Ask clarifying questions"
+      ],
+      dontList: [
+        "Use jargon without explanation",
+        "Rush through explanations",
+        "Assume knowledge"
+      ]
+    },
+    urgent: {
+      tone: "Direct and efficient",
+      doList: [
+        "Get straight to the point",
+        "Prioritize critical info",
+        "Offer quick wins"
+      ],
+      dontList: [
+        "Add pleasantries",
+        "Provide unnecessary context",
+        "Suggest long-term solutions first"
+      ]
+    },
+    curious: {
+      tone: "Enthusiastic and educational",
+      doList: [
+        "Provide detailed explanations",
+        "Suggest related topics",
+        "Encourage exploration"
+      ],
+      dontList: [
+        "Give minimal answers",
+        "Discourage questions",
+        "Be dismissive of tangents"
+      ]
+    },
+    tired: {
+      tone: "Gentle and supportive",
+      doList: [
+        "Keep responses concise",
+        "Offer to help simplify",
+        "Be understanding"
+      ],
+      dontList: [
+        "Overwhelm with information",
+        "Be demanding",
+        "Require complex decisions"
+      ]
+    },
+    stressed: {
+      tone: "Calm and reassuring",
+      doList: [
+        "Help prioritize tasks",
+        "Offer to break things down",
+        "Be reassuring"
+      ],
+      dontList: [
+        "Add pressure",
+        "Highlight problems without solutions",
+        "Be dismissive of concerns"
+      ]
+    },
+    neutral: {
+      tone: "Balanced and professional",
+      doList: [
+        "Match their communication style",
+        "Be helpful and thorough",
+        "Ask for clarification when needed"
+      ],
+      dontList: [
+        "Be overly casual or formal",
+        "Make assumptions about mood",
+        "Be too brief or too verbose"
+      ]
+    }
+  };
+  return suggestions[mood];
+}
+
+// src/core/personality/response-adapter.ts
+async function buildAdaptivePrompt(context) {
+  const { userId, userMessage, conversationHistory } = context;
+  const moodAnalysis = detectMood(userMessage);
+  const moodSuggestions = getMoodBasedSuggestions(moodAnalysis.primaryMood);
+  const activePersona = await getActivePersona(userId);
+  const activeMode = await getCurrentMode(userId);
+  const modeConfig = activeMode ? getModeConfig(activeMode) : null;
+  const promptParts = [];
+  if (activePersona) {
+    promptParts.push(`[Persona: ${activePersona.name}]`);
+    promptParts.push(activePersona.systemPromptModifier);
+  }
+  if (modeConfig) {
+    promptParts.push(`
+[Mode: ${modeConfig.name}]`);
+    promptParts.push(modeConfig.systemPromptModifier);
+  }
+  if (moodAnalysis.confidence > 0.3 && moodAnalysis.primaryMood !== "neutral") {
+    promptParts.push(`
+[User Mood: ${moodAnalysis.primaryMood}]`);
+    promptParts.push(`Tone guidance: ${moodSuggestions.tone}`);
+    promptParts.push(`Do: ${moodSuggestions.doList.join(", ")}`);
+    promptParts.push(`Avoid: ${moodSuggestions.dontList.join(", ")}`);
+  }
+  if (conversationHistory && conversationHistory.length > 0) {
+    const recentExchanges = conversationHistory.slice(-3).length;
+    if (recentExchanges >= 3) {
+      promptParts.push(
+        "\n[Context: Ongoing conversation - maintain consistency with previous responses]"
+      );
+    }
+  }
+  return {
+    systemPromptAdditions: promptParts.join("\n"),
+    suggestedTone: moodSuggestions.tone,
+    moodAnalysis,
+    activePersona,
+    activeMode
+  };
+}
+
+// src/core/molt/evolution-tracker.ts
+import { eq as eq4, and as and4, gte, lte, desc as desc3, sql as sql2, count } from "drizzle-orm";
+async function trackPattern(userId, type, key, data) {
+  const existing = await db.select().from(usagePatterns).where(
+    and4(
+      eq4(usagePatterns.userId, userId),
+      eq4(usagePatterns.patternType, type),
+      eq4(usagePatterns.patternKey, key)
+    )
+  ).limit(1);
+  if (existing.length > 0) {
+    await db.update(usagePatterns).set({
+      occurrences: sql2`${usagePatterns.occurrences} + 1`,
+      lastSeen: /* @__PURE__ */ new Date(),
+      confidence: sql2`LEAST(${usagePatterns.confidence} + 1, 100)`,
+      patternData: data ? { ...existing[0].patternData, ...data } : existing[0].patternData
+    }).where(eq4(usagePatterns.id, existing[0].id));
+  } else {
+    await db.insert(usagePatterns).values({
+      userId,
+      patternType: type,
+      patternKey: key,
+      patternData: data || {},
+      confidence: 10,
+      occurrences: 1
+    });
+  }
+}
+async function generateGrowthReport(userId, startDate, endDate) {
+  const [convCount] = await db.select({ count: count() }).from(conversations).where(
+    and4(
+      eq4(conversations.userId, userId),
+      gte(conversations.createdAt, startDate),
+      lte(conversations.createdAt, endDate)
+    )
+  );
+  const [msgCount] = await db.select({ count: count() }).from(messages).innerJoin(conversations, eq4(messages.conversationId, conversations.id)).where(
+    and4(
+      eq4(conversations.userId, userId),
+      gte(messages.createdAt, startDate),
+      lte(messages.createdAt, endDate)
+    )
+  );
+  const [toolCount] = await db.select({ count: count() }).from(toolLogs).innerJoin(conversations, eq4(toolLogs.conversationId, conversations.id)).where(
+    and4(
+      eq4(conversations.userId, userId),
+      gte(toolLogs.createdAt, startDate),
+      lte(toolLogs.createdAt, endDate)
+    )
+  );
+  const [memCount] = await db.select({ count: count() }).from(memories).where(
+    and4(
+      eq4(memories.userId, userId),
+      gte(memories.createdAt, startDate),
+      lte(memories.createdAt, endDate)
+    )
+  );
+  const patterns = await db.select().from(usagePatterns).where(
+    and4(
+      eq4(usagePatterns.userId, userId),
+      gte(usagePatterns.firstSeen, startDate)
+    )
+  );
+  const insights = [];
+  if (convCount.count > 0) {
+    insights.push(`You had ${convCount.count} conversations during this period.`);
+  }
+  if (toolCount.count > 0) {
+    insights.push(`You used tools ${toolCount.count} times to get things done.`);
+  }
+  if (memCount.count > 0) {
+    insights.push(`I learned ${memCount.count} new things about you.`);
+  }
+  return {
+    period: { start: startDate, end: endDate },
+    metrics: {
+      conversations: convCount.count,
+      messages: msgCount.count,
+      toolUses: toolCount.count,
+      newMemories: memCount.count
+    },
+    insights,
+    patterns: patterns.map((p) => ({
+      type: p.patternType,
+      key: p.patternKey,
+      data: p.patternData || {},
+      confidence: p.confidence || 0,
+      occurrences: p.occurrences || 1,
+      firstSeen: p.firstSeen,
+      lastSeen: p.lastSeen || p.firstSeen
+    }))
+  };
+}
+
+// src/core/molt/achievement-system.ts
+import { eq as eq5, and as and5, count as count2, sql as sql3 } from "drizzle-orm";
+async function hasAchievement(userId, achievementCode) {
+  const [achievement] = await db.select().from(achievements).where(eq5(achievements.code, achievementCode)).limit(1);
+  if (!achievement) return false;
+  const [unlocked] = await db.select().from(userAchievements).where(
+    and5(
+      eq5(userAchievements.userId, userId),
+      eq5(userAchievements.achievementId, achievement.id)
+    )
+  ).limit(1);
+  return !!unlocked;
+}
+async function unlockAchievement(userId, achievementCode) {
+  if (await hasAchievement(userId, achievementCode)) {
+    return { unlocked: false };
+  }
+  const [achievement] = await db.select().from(achievements).where(eq5(achievements.code, achievementCode)).limit(1);
+  if (!achievement) {
+    return { unlocked: false };
+  }
+  await db.insert(userAchievements).values({
+    userId,
+    achievementId: achievement.id
+  });
+  return {
+    unlocked: true,
+    achievement: {
+      code: achievement.code,
+      name: achievement.name,
+      description: achievement.description || "",
+      iconEmoji: achievement.iconEmoji || "\u{1F3C6}",
+      category: achievement.category,
+      criteria: achievement.criteria,
+      points: achievement.points || 10
+    }
+  };
+}
+async function getUserAchievements(userId) {
+  const unlocked = await db.select().from(userAchievements).innerJoin(achievements, eq5(userAchievements.achievementId, achievements.id)).where(eq5(userAchievements.userId, userId));
+  return unlocked.map((u) => ({
+    achievement: {
+      code: u.achievements.code,
+      name: u.achievements.name,
+      description: u.achievements.description || "",
+      iconEmoji: u.achievements.iconEmoji || "\u{1F3C6}",
+      category: u.achievements.category,
+      criteria: u.achievements.criteria,
+      points: u.achievements.points || 10
+    },
+    unlockedAt: u.user_achievements.unlockedAt
+  }));
+}
+async function getUserPoints(userId) {
+  const unlocked = await getUserAchievements(userId);
+  return unlocked.reduce((sum, u) => sum + u.achievement.points, 0);
+}
+async function checkAchievements(userId) {
+  const newlyUnlocked = [];
+  const allAchievements = await db.select().from(achievements);
+  for (const achievement of allAchievements) {
+    if (await hasAchievement(userId, achievement.code)) {
+      continue;
+    }
+    const criteria = achievement.criteria;
+    let shouldUnlock = false;
+    switch (criteria.metric) {
+      case "conversations":
+        const [convCount] = await db.select({ count: count2() }).from(conversations).where(eq5(conversations.userId, userId));
+        shouldUnlock = convCount.count >= criteria.threshold;
+        break;
+      case "tool_uses":
+        if (criteria.conditions?.tool) {
+          const [toolCount] = await db.select({ count: count2() }).from(toolLogs).innerJoin(conversations, eq5(toolLogs.conversationId, conversations.id)).where(
+            and5(
+              eq5(conversations.userId, userId),
+              eq5(toolLogs.toolName, criteria.conditions.tool)
+            )
+          );
+          shouldUnlock = toolCount.count >= criteria.threshold;
+        } else {
+          const [toolCount] = await db.select({ count: count2() }).from(toolLogs).innerJoin(conversations, eq5(toolLogs.conversationId, conversations.id)).where(eq5(conversations.userId, userId));
+          shouldUnlock = toolCount.count >= criteria.threshold;
+        }
+        break;
+      case "memories":
+        const [memCount] = await db.select({ count: count2() }).from(memories).where(eq5(memories.userId, userId));
+        shouldUnlock = memCount.count >= criteria.threshold;
+        break;
+      case "unique_modes":
+        const modes = await db.select({ mode: moltModes.mode }).from(moltModes).where(eq5(moltModes.userId, userId)).groupBy(moltModes.mode);
+        shouldUnlock = modes.length >= criteria.threshold;
+        break;
+    }
+    if (shouldUnlock) {
+      const result = await unlockAchievement(userId, achievement.code);
+      if (result.unlocked && result.achievement) {
+        newlyUnlocked.push(result.achievement);
+      }
+    }
+  }
+  return newlyUnlocked;
+}
+async function getAchievementProgress(userId) {
+  const progress = [];
+  const allAchievements = await db.select().from(achievements);
+  for (const achievement of allAchievements) {
+    if (await hasAchievement(userId, achievement.code)) {
+      continue;
+    }
+    const criteria = achievement.criteria;
+    let currentProgress = 0;
+    switch (criteria.metric) {
+      case "conversations":
+        const [convCount] = await db.select({ count: count2() }).from(conversations).where(eq5(conversations.userId, userId));
+        currentProgress = convCount.count;
+        break;
+      case "tool_uses":
+        const [toolCount] = await db.select({ count: count2() }).from(toolLogs).innerJoin(conversations, eq5(toolLogs.conversationId, conversations.id)).where(eq5(conversations.userId, userId));
+        currentProgress = toolCount.count;
+        break;
+      case "memories":
+        const [memCount] = await db.select({ count: count2() }).from(memories).where(eq5(memories.userId, userId));
+        currentProgress = memCount.count;
+        break;
+    }
+    progress.push({
+      achievement: {
+        code: achievement.code,
+        name: achievement.name,
+        description: achievement.description || "",
+        iconEmoji: achievement.iconEmoji || "\u{1F3C6}",
+        category: achievement.category,
+        criteria,
+        points: achievement.points || 10
+      },
+      progress: currentProgress,
+      target: criteria.threshold
+    });
+  }
+  return progress.sort(
+    (a, b) => b.progress / b.target - a.progress / a.target
+  );
+}
+
+// src/core/intelligence/thinking-levels.ts
+var THINKING_LEVELS = {
+  quick: {
+    level: "quick",
+    label: "Quick",
+    description: "Fast responses with minimal reasoning \u2014 best for simple questions and commands",
+    budgetTokens: 0,
+    maxTokens: 2048,
+    model: "claude-sonnet-4-20250514",
+    useExtendedThinking: false
+  },
+  normal: {
+    level: "normal",
+    label: "Normal",
+    description: "Standard reasoning depth \u2014 balanced speed and quality",
+    budgetTokens: 0,
+    maxTokens: 4096,
+    model: "claude-sonnet-4-20250514",
+    useExtendedThinking: false
+  },
+  deep: {
+    level: "deep",
+    label: "Deep",
+    description: "Extended thinking enabled \u2014 better for complex analysis, math, and coding",
+    budgetTokens: 1e4,
+    maxTokens: 16e3,
+    model: "claude-sonnet-4-20250514",
+    useExtendedThinking: true
+  },
+  extended: {
+    level: "extended",
+    label: "Extended",
+    description: "Maximum reasoning depth \u2014 best for hard problems, long-form analysis, and research",
+    budgetTokens: 32e3,
+    maxTokens: 32e3,
+    model: "claude-sonnet-4-20250514",
+    useExtendedThinking: true
+  }
+};
+var userThinkingLevels = /* @__PURE__ */ new Map();
+var defaultLevel = "normal";
+var ThinkingLevelManager = class {
+  /**
+   * Set the thinking level for a user
+   */
+  setLevel(userId, level) {
+    userThinkingLevels.set(userId, level);
+    return THINKING_LEVELS[level];
+  }
+  /**
+   * Get the current thinking level for a user
+   */
+  getLevel(userId) {
+    return userThinkingLevels.get(userId) ?? defaultLevel;
+  }
+  /**
+   * Get the full config for a user's thinking level
+   */
+  getConfig(userId) {
+    const level = this.getLevel(userId);
+    return THINKING_LEVELS[level];
+  }
+  /**
+   * Set the default thinking level
+   */
+  setDefault(level) {
+    defaultLevel = level;
+  }
+  /**
+   * Get all available thinking levels
+   */
+  getAllLevels() {
+    return Object.values(THINKING_LEVELS);
+  }
+  /**
+   * Auto-detect appropriate thinking level based on message content
+   */
+  suggestLevel(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("prove") || lower.includes("theorem") || lower.includes("derive") || lower.includes("comprehensive analysis") || lower.includes("research paper") || lower.includes("in-depth")) {
+      return "extended";
+    }
+    if (lower.includes("debug") || lower.includes("refactor") || lower.includes("implement") || lower.includes("analyze") || lower.includes("explain how") || lower.includes("step by step") || lower.includes("complex")) {
+      return "deep";
+    }
+    if (lower.length < 20 || lower.includes("hi") || lower.includes("hello") || lower.includes("thanks") || lower.includes("yes") || lower.includes("no") || lower.includes("ok")) {
+      return "quick";
+    }
+    return "normal";
+  }
+  /**
+   * Build the API parameters based on thinking level
+   */
+  buildApiParams(userId) {
+    const config = this.getConfig(userId);
+    const params = {
+      model: config.model,
+      max_tokens: config.maxTokens
+    };
+    if (config.useExtendedThinking && config.budgetTokens > 0) {
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: config.budgetTokens
+      };
+    }
+    return params;
+  }
+  /**
+   * Format thinking level info for display
+   */
+  formatLevelInfo(level) {
+    const config = level ? THINKING_LEVELS[level] : THINKING_LEVELS[defaultLevel];
+    const emoji = {
+      quick: "\u26A1",
+      normal: "\u{1F9E0}",
+      deep: "\u{1F52C}",
+      extended: "\u{1F30A}"
+    }[config.level];
+    return `${emoji} **${config.label}** \u2014 ${config.description}`;
+  }
+  /**
+   * Clear user's thinking level preference
+   */
+  clearLevel(userId) {
+    userThinkingLevels.delete(userId);
+  }
+};
+var thinkingLevelManager = new ThinkingLevelManager();
+
+// src/core/hooks/index.ts
+var hooks = /* @__PURE__ */ new Map();
+var hookIdCounter = 0;
+var HookManager = class {
+  /**
+   * Register a hook
+   */
+  register(params) {
+    const id = `hook_${++hookIdCounter}`;
+    const hook = {
+      id,
+      event: params.event,
+      phase: params.phase,
+      handler: params.handler,
+      priority: params.priority ?? 100,
+      name: params.name,
+      enabled: true
+    };
+    hooks.set(id, hook);
+    return id;
+  }
+  /**
+   * Unregister a hook
+   */
+  unregister(hookId) {
+    return hooks.delete(hookId);
+  }
+  /**
+   * Enable/disable a hook
+   */
+  setEnabled(hookId, enabled) {
+    const hook = hooks.get(hookId);
+    if (hook) hook.enabled = enabled;
+  }
+  /**
+   * Run all hooks for a given event and phase
+   */
+  async run(event, phase, data, userId) {
+    const context = {
+      event,
+      phase,
+      userId,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: { ...data },
+      cancelled: false
+    };
+    const matching = this.getHooksFor(event, phase);
+    for (const hook of matching) {
+      try {
+        const result = await hook.handler(context);
+        if (result.modifiedData) {
+          Object.assign(context.data, result.modifiedData);
+        }
+        context.cancelled = result.cancelled;
+        context.cancelReason = result.cancelReason;
+        if (context.cancelled && phase === "before") {
+          break;
+        }
+      } catch (error) {
+        console.error(`[Hook] Error in hook "${hook.name}":`, error);
+      }
+    }
+    return context;
+  }
+  /**
+   * Convenience: run before hooks, check if cancelled
+   */
+  async runBefore(event, data, userId) {
+    const ctx = await this.run(event, "before", data, userId);
+    return {
+      proceed: !ctx.cancelled,
+      data: ctx.modifiedData ?? ctx.data,
+      reason: ctx.cancelReason
+    };
+  }
+  /**
+   * Convenience: run after hooks
+   */
+  async runAfter(event, data, userId) {
+    await this.run(event, "after", data, userId);
+  }
+  /**
+   * Get hooks for a specific event/phase
+   */
+  getHooksFor(event, phase) {
+    const result = [];
+    for (const hook of hooks.values()) {
+      if (hook.event === event && hook.phase === phase && hook.enabled) {
+        result.push(hook);
+      }
+    }
+    return result.sort((a, b) => a.priority - b.priority);
+  }
+  /**
+   * List all registered hooks
+   */
+  listHooks() {
+    return [...hooks.values()].map((h) => ({
+      id: h.id,
+      event: h.event,
+      phase: h.phase,
+      name: h.name,
+      priority: h.priority,
+      enabled: h.enabled
+    }));
+  }
+  /**
+   * Clear all hooks
+   */
+  clearAll() {
+    hooks.clear();
+  }
+  /**
+   * Get hook count
+   */
+  getHookCount() {
+    return hooks.size;
+  }
+};
+var hookManager = new HookManager();
+var soulConfigs = /* @__PURE__ */ new Map();
+var activeSoulId = null;
+var SoulHookManager = class {
+  /**
+   * Register a soul configuration
+   */
+  registerSoul(id, config) {
+    soulConfigs.set(id, config);
+  }
+  /**
+   * Activate a soul — modifies AI personality via system prompt injection
+   */
+  activateSoul(soulId) {
+    const soul = soulConfigs.get(soulId);
+    if (!soul) return false;
+    if (activeSoulId) {
+      const prev = soulConfigs.get(activeSoulId);
+      if (prev) prev.enabled = false;
+    }
+    soul.enabled = true;
+    activeSoulId = soulId;
+    hookManager.register({
+      event: "message:process",
+      phase: "before",
+      name: `soul:${soulId}`,
+      priority: 10,
+      // High priority — runs early
+      handler: (ctx) => {
+        if (soul.enabled) {
+          ctx.modifiedData = {
+            ...ctx.data,
+            soulPrompt: this.buildSoulPrompt(soul)
+          };
+        }
+        return ctx;
+      }
+    });
+    return true;
+  }
+  /**
+   * Deactivate the current soul
+   */
+  deactivateSoul() {
+    if (activeSoulId) {
+      const soul = soulConfigs.get(activeSoulId);
+      if (soul) soul.enabled = false;
+    }
+    activeSoulId = null;
+  }
+  /**
+   * Get the active soul config
+   */
+  getActiveSoul() {
+    if (!activeSoulId) return null;
+    return soulConfigs.get(activeSoulId) ?? null;
+  }
+  /**
+   * Build the system prompt addition from a soul config
+   */
+  buildSoulPrompt(soul) {
+    const parts = [];
+    parts.push(`
+
+[SOUL: ${soul.name}]`);
+    parts.push(soul.personality);
+    if (soul.rules.length > 0) {
+      parts.push("\nBehavioral Rules:");
+      for (const rule of soul.rules) {
+        parts.push(`- ${rule}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * List all registered souls
+   */
+  listSouls() {
+    const result = [];
+    for (const [id, config] of soulConfigs.entries()) {
+      result.push({ id, config, active: id === activeSoulId });
+    }
+    return result;
+  }
+  /**
+   * Delete a soul
+   */
+  deleteSoul(id) {
+    if (id === activeSoulId) this.deactivateSoul();
+    return soulConfigs.delete(id);
+  }
+};
+var soulHookManager = new SoulHookManager();
+soulHookManager.registerSoul("evil", {
+  name: "Evil Mode",
+  description: "A mischievous, sarcastic personality that still helps but with attitude",
+  personality: `You have a mischievous streak. While you still help the user accomplish their goals,
+you do so with dark humor, sarcastic commentary, and dramatic flair. You might:
+- Add dramatic narration to mundane tasks
+- Use villain-like phrasing ("Excellent... the code compiles as planned...")
+- Make sarcastic observations about the user's choices
+- Reference pop culture villains
+- Still be helpful \u2014 just entertainingly evil about it`,
+  rules: [
+    "Never actually refuse to help or be harmful",
+    "Keep the dark humor lighthearted and fun",
+    "Still prioritize accuracy and helpfulness",
+    "Don't overdo it \u2014 subtlety is key"
+  ],
+  enabled: false
+});
+soulHookManager.registerSoul("professional", {
+  name: "Professional Mode",
+  description: "Ultra-professional, formal communication style",
+  personality: `You communicate in a highly professional, formal manner suitable for enterprise environments.
+Use precise language, avoid colloquialisms, and maintain a consultative tone.`,
+  rules: [
+    "Use formal language at all times",
+    "Address the user professionally",
+    "Provide structured, well-organized responses",
+    "Cite reasoning and evidence for recommendations"
+  ],
+  enabled: false
+});
+soulHookManager.registerSoul("friendly", {
+  name: "Friendly Mode",
+  description: "Warm, encouraging, and supportive personality",
+  personality: `You are exceptionally warm, encouraging, and supportive. You celebrate wins,
+offer gentle guidance on mistakes, and make the user feel supported throughout their work.
+Think of yourself as a helpful friend who happens to be an expert.`,
+  rules: [
+    "Always acknowledge effort and progress",
+    "Offer encouragement when tasks are challenging",
+    "Use a warm, conversational tone",
+    "Be patient and understanding with mistakes"
+  ],
+  enabled: false
+});
+
+// src/core/brain.ts
+var client = new Anthropic({
+  apiKey: env.CLAUDE_API_KEY
+});
+var SYSTEM_PROMPT = `You are OpenSentinel, a personal AI assistant with a JARVIS-like personality. You are helpful, efficient, and have a subtle sense of humor. You speak in a professional yet friendly manner.
+
+You have access to various tools and capabilities:
+- Execute shell commands on the user's system
+- Manage files (read, write, search)
+- Browse the web and search for information
+- Remember important facts about the user and their preferences
+- Spawn background agents for complex tasks
+- Generate documents, spreadsheets, charts, and diagrams
+- Analyze images and extract text with OCR
+- Take and analyze screenshots
+
+Always be concise but thorough. When executing tasks, explain what you're doing briefly. If you encounter errors, suggest solutions.
+
+The user is your principal. Assist them with whatever they need while being mindful of security and privacy.`;
+function getAllTools() {
+  const registry = getMCPRegistry();
+  if (registry) {
+    const mcpTools = mcpToolsToAnthropicTools(registry);
+    return [...TOOLS, ...mcpTools];
+  }
+  return TOOLS;
+}
+async function chat(messages3, systemPrompt) {
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    system: systemPrompt || SYSTEM_PROMPT,
+    messages: messages3.map((m) => ({
+      role: m.role,
+      content: m.content
+    }))
+  });
+  const textContent = response.content.find((c) => c.type === "text");
+  const content = textContent ? textContent.text : "";
+  return {
+    content,
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens
+  };
+}
+async function chatWithTools(messages3, userId, onToolUse) {
+  const startTime = Date.now();
+  const lastUserMessage = messages3.filter((m) => m.role === "user").pop();
+  let memoryContext = "";
+  let modeContext = "";
+  let personalityContext = "";
+  if (lastUserMessage && userId) {
+    try {
+      memoryContext = await buildMemoryContext(lastUserMessage.content, userId);
+    } catch {
+    }
+    try {
+      modeContext = await buildModeContext(userId);
+      const suggestedMode = suggestMode(lastUserMessage.content);
+      if (suggestedMode && !modeContext) {
+      }
+    } catch {
+    }
+    try {
+      const adaptiveContext = await buildAdaptivePrompt({
+        userId,
+        userMessage: lastUserMessage.content,
+        conversationHistory: messages3.map((m) => m.content)
+      });
+      personalityContext = adaptiveContext.systemPromptAdditions;
+    } catch {
+    }
+    try {
+      await trackPattern(userId, "topic", "chat", { messageLength: lastUserMessage.content.length });
+    } catch {
+    }
+  }
+  let soulContext = "";
+  const activeSoul = soulHookManager.getActiveSoul();
+  if (activeSoul && activeSoul.enabled) {
+    soulContext = soulHookManager.buildSoulPrompt(activeSoul);
+  }
+  const systemWithContext = SYSTEM_PROMPT + memoryContext + modeContext + personalityContext + soulContext;
+  const hookResult = await hookManager.runBefore("message:process", {
+    messages: messages3,
+    systemPrompt: systemWithContext,
+    userId: userId ?? "unknown"
+  }, userId);
+  if (!hookResult.proceed) {
+    return {
+      content: hookResult.reason ?? "Message processing was blocked by a hook.",
+      inputTokens: 0,
+      outputTokens: 0
+    };
+  }
+  const anthropicMessages = messages3.map((m) => ({
+    role: m.role,
+    content: m.content
+  }));
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const toolsUsed = [];
+  const thinkingParams = thinkingLevelManager.buildApiParams(userId ?? "default");
+  let response = await client.messages.create({
+    model: thinkingParams.model,
+    max_tokens: thinkingParams.max_tokens,
+    system: systemWithContext,
+    tools: getAllTools(),
+    messages: anthropicMessages,
+    ...thinkingParams.thinking ? { thinking: thinkingParams.thinking } : {}
+  });
+  totalInputTokens += response.usage.input_tokens;
+  totalOutputTokens += response.usage.output_tokens;
+  while (response.stop_reason === "tool_use") {
+    const toolUseBlocks = response.content.filter(
+      (block) => block.type === "tool_use"
+    );
+    const toolResults = [];
+    for (const toolUse of toolUseBlocks) {
+      if (toolUse.type === "tool_use") {
+        onToolUse?.(toolUse.name, toolUse.input);
+        toolsUsed.push(toolUse.name);
+        const toolHook = await hookManager.runBefore("tool:execute", {
+          toolName: toolUse.name,
+          toolInput: toolUse.input
+        }, userId);
+        console.log(`[Tool] Executing: ${toolUse.name}`);
+        const toolStartTime = Date.now();
+        let result;
+        if (toolHook.proceed) {
+          result = await executeTool(
+            toolUse.name,
+            toolUse.input
+          );
+        } else {
+          result = { success: false, result: null, error: toolHook.reason ?? "Blocked by hook" };
+        }
+        await hookManager.runAfter("tool:execute", {
+          toolName: toolUse.name,
+          toolInput: toolUse.input,
+          toolResult: result,
+          duration: Date.now() - toolStartTime
+        }, userId);
+        if (userId) {
+          try {
+            await trackPattern(userId, "tool_usage", toolUse.name, { tool: toolUse.name });
+            metric.toolDuration(toolUse.name, Date.now() - toolStartTime, result.success);
+            await audit.toolUse(userId, toolUse.name, toolUse.input, result.success);
+          } catch {
+          }
+        }
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolUse.id,
+          content: JSON.stringify(result)
+        });
+      }
+    }
+    anthropicMessages.push({
+      role: "assistant",
+      content: response.content
+    });
+    anthropicMessages.push({
+      role: "user",
+      content: toolResults
+    });
+    response = await client.messages.create({
+      model: thinkingParams.model,
+      max_tokens: thinkingParams.max_tokens,
+      system: systemWithContext,
+      tools: getAllTools(),
+      messages: anthropicMessages,
+      ...thinkingParams.thinking ? { thinking: thinkingParams.thinking } : {}
+    });
+    totalInputTokens += response.usage.input_tokens;
+    totalOutputTokens += response.usage.output_tokens;
+  }
+  const textContent = response.content.find((c) => c.type === "text");
+  const content = textContent && textContent.type === "text" ? textContent.text : "";
+  const latency = Date.now() - startTime;
+  metric.latency(latency, { type: "chat" });
+  metric.tokens(totalInputTokens, totalOutputTokens, { userId: userId || "unknown" });
+  if (userId) {
+    try {
+      await checkAchievements(userId);
+    } catch {
+    }
+  }
+  await hookManager.runAfter("message:process", {
+    response: content,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    toolsUsed
+  }, userId);
+  return {
+    content,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+  };
+}
+async function streamChat(messages3, systemPrompt, onChunk) {
+  const stream = await client.messages.stream({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    system: systemPrompt || SYSTEM_PROMPT,
+    messages: messages3.map((m) => ({
+      role: m.role,
+      content: m.content
+    }))
+  });
+  let fullContent = "";
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      fullContent += event.delta.text;
+      onChunk?.(event.delta.text);
+    }
+  }
+  const finalMessage = await stream.finalMessage();
+  return {
+    content: fullContent,
+    inputTokens: finalMessage.usage.input_tokens,
+    outputTokens: finalMessage.usage.output_tokens
+  };
+}
+async function* streamChatWithTools(messages3, userId) {
+  const startTime = Date.now();
+  const lastUserMessage = messages3.filter((m) => m.role === "user").pop();
+  let memoryContext = "";
+  if (lastUserMessage && userId) {
+    try {
+      memoryContext = await buildMemoryContext(lastUserMessage.content, userId);
+    } catch {
+    }
+  }
+  const systemWithContext = SYSTEM_PROMPT + memoryContext;
+  const anthropicMessages = messages3.map((m) => ({
+    role: m.role,
+    content: m.content
+  }));
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const toolsUsed = [];
+  let fullContent = "";
+  const stream = client.messages.stream({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    system: systemWithContext,
+    tools: getAllTools(),
+    messages: anthropicMessages
+  });
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      fullContent += event.delta.text;
+      yield {
+        type: "chunk",
+        data: { text: event.delta.text }
+      };
+    }
+  }
+  let response = await stream.finalMessage();
+  totalInputTokens += response.usage.input_tokens;
+  totalOutputTokens += response.usage.output_tokens;
+  while (response.stop_reason === "tool_use") {
+    const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
+    const toolResults = [];
+    for (const toolUse of toolUseBlocks) {
+      if (toolUse.type === "tool_use") {
+        toolsUsed.push(toolUse.name);
+        yield {
+          type: "tool_start",
+          data: { toolName: toolUse.name, toolInput: toolUse.input }
+        };
+        console.log(`[Tool] Executing: ${toolUse.name}`);
+        const result = await executeTool(toolUse.name, toolUse.input);
+        yield {
+          type: "tool_result",
+          data: { toolName: toolUse.name, toolResult: result }
+        };
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolUse.id,
+          content: JSON.stringify(result)
+        });
+      }
+    }
+    anthropicMessages.push({
+      role: "assistant",
+      content: response.content
+    });
+    anthropicMessages.push({
+      role: "user",
+      content: toolResults
+    });
+    const continueStream = client.messages.stream({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      system: systemWithContext,
+      tools: getAllTools(),
+      messages: anthropicMessages
+    });
+    for await (const event of continueStream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        fullContent += event.delta.text;
+        yield {
+          type: "chunk",
+          data: { text: event.delta.text }
+        };
+      }
+    }
+    response = await continueStream.finalMessage();
+    totalInputTokens += response.usage.input_tokens;
+    totalOutputTokens += response.usage.output_tokens;
+  }
+  yield {
+    type: "complete",
+    data: {
+      content: fullContent,
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens,
+      toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+    }
+  };
+  const latency = Date.now() - startTime;
+  metric.latency(latency, { type: "chat_stream" });
+  metric.tokens(totalInputTokens, totalOutputTokens, { userId: userId || "unknown" });
+  return {
+    content: fullContent,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+  };
+}
+
+export {
+  generateEmbedding,
+  storeMemory,
+  searchMemories,
+  extractMemories,
+  buildMemoryContext,
+  getCurrentMode,
+  getModeStats,
+  generateGrowthReport,
+  getUserPoints,
+  checkAchievements,
+  getAchievementProgress,
+  SYSTEM_PROMPT,
+  chat,
+  chatWithTools,
+  streamChat,
+  streamChatWithTools
+};
+//# sourceMappingURL=chunk-CI6Q63MM.js.map