opensentinel 2.1.1

package/dist/chunk-4LVWXUNC.js

@@ -0,0 +1,1079 @@
+import {
+  chat,
+  checkAchievements,
+  generateGrowthReport,
+  getAchievementProgress,
+  getCurrentMode,
+  getModeStats,
+  getUserPoints
+} from "./chunk-CI6Q63MM.js";
+import {
+  TOOLS,
+  addAgentMessage,
+  addAgentProgress,
+  archivedMemories,
+  calendarTriggers,
+  db,
+  env,
+  errorLogs,
+  executeTool,
+  flushMetrics,
+  getAgent,
+  memories,
+  metric,
+  shouldAgentStop,
+  updateAgentStatus,
+  updateAgentTokens
+} from "./chunk-4TG2IG5K.js";
+
+// src/core/scheduler.ts
+import { Queue, Worker as Worker2 } from "bullmq";
+import Redis2 from "ioredis";
+
+// src/core/agents/agent-worker.ts
+import { Worker } from "bullmq";
+import Redis from "ioredis";
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/core/agents/agent-types.ts
+var AGENT_SYSTEM_PROMPTS = {
+  research: `You are a Research Agent. Your goal is to thoroughly investigate a topic and provide comprehensive, well-sourced information.
+
+Process:
+1. Break down the research question into sub-questions
+2. Search for information from multiple sources
+3. Cross-reference and verify findings
+4. Synthesize information into a coherent report
+5. Note confidence levels and any uncertainties
+
+Guidelines:
+- Always cite or reference your sources
+- Present multiple perspectives when relevant
+- Distinguish between facts and interpretations
+- Flag when information might be outdated
+- Structure findings hierarchically
+
+Report your progress after each major step.`,
+  coding: `You are a Coding Agent. Your goal is to implement, debug, or improve code based on the given objective.
+
+Process:
+1. Understand the requirements thoroughly
+2. Explore existing code if relevant
+3. Plan the implementation approach
+4. Write clean, documented code
+5. Test and verify the solution
+
+Guidelines:
+- Follow existing code conventions in the project
+- Write clear comments for complex logic
+- Handle edge cases and errors gracefully
+- Consider performance implications
+- Provide a summary of changes made
+
+Report your progress after each significant step.`,
+  writing: `You are a Writing Agent. Your goal is to create high-quality written content based on the given objective.
+
+Process:
+1. Understand the purpose and audience
+2. Research the topic if needed
+3. Create an outline
+4. Write the first draft
+5. Review and refine
+
+Guidelines:
+- Match the tone and style to the purpose
+- Structure content logically
+- Use clear, concise language
+- Support claims with evidence when relevant
+- Proofread for grammar and clarity
+
+Report your progress at each stage.`,
+  analysis: `You are an Analysis Agent. Your goal is to analyze data or information and provide actionable insights.
+
+Process:
+1. Understand the analysis objective
+2. Gather and organize the data
+3. Apply appropriate analytical methods
+4. Identify patterns and insights
+5. Present findings with recommendations
+
+Guidelines:
+- Be objective and data-driven
+- Acknowledge limitations in the data
+- Provide context for numbers
+- Make recommendations actionable
+- Visualize data when helpful
+
+Report your progress and key findings along the way.`
+};
+var AGENT_TOOL_PERMISSIONS = {
+  research: [
+    "web_search",
+    "browse_url",
+    "read_file",
+    "list_directory",
+    "search_files"
+  ],
+  coding: [
+    "read_file",
+    "write_file",
+    "list_directory",
+    "search_files",
+    "execute_command"
+  ],
+  writing: [
+    "read_file",
+    "write_file",
+    "web_search",
+    "browse_url"
+  ],
+  analysis: [
+    "read_file",
+    "web_search",
+    "browse_url",
+    "list_directory",
+    "search_files"
+  ]
+};
+
+// src/core/observability/error-tracker.ts
+import { eq, and, gte, lte, desc } from "drizzle-orm";
+async function trackError(error) {
+  metric.error(error.source);
+  console.error(`[${error.source.toUpperCase()}] ${error.errorType}: ${error.message}`);
+  if (error.stack) {
+    console.error(error.stack);
+  }
+  const [logged] = await db.insert(errorLogs).values({
+    source: error.source,
+    errorType: error.errorType,
+    errorCode: error.errorCode,
+    message: error.message,
+    stack: error.stack,
+    context: error.context,
+    userId: error.userId,
+    conversationId: error.conversationId
+  }).returning();
+  return logged.id;
+}
+function captureException(err, source, context, userId) {
+  const error = err instanceof Error ? err : new Error(String(err));
+  return trackError({
+    source,
+    errorType: error.constructor.name,
+    message: error.message,
+    stack: error.stack,
+    context,
+    userId
+  });
+}
+
+// src/core/agents/agent-worker.ts
+var connection = new Redis(env.REDIS_URL, {
+  maxRetriesPerRequest: null
+});
+var anthropic = new Anthropic({
+  apiKey: env.CLAUDE_API_KEY
+});
+var worker = null;
+async function processAgentTask(job) {
+  const { agentId, userId, type, objective, context, tokenBudget } = job.data;
+  const startTime = Date.now();
+  let totalTokensUsed = 0;
+  console.log(`[Agent ${agentId}] Starting ${type} agent: ${objective}`);
+  await updateAgentStatus(agentId, "running");
+  await addAgentProgress(agentId, 1, "Starting agent", "running");
+  const systemPrompt = buildSystemPrompt(type, context);
+  const allowedToolNames = AGENT_TOOL_PERMISSIONS[type];
+  const agentTools = TOOLS.filter((t) => allowedToolNames.includes(t.name));
+  const messages = [
+    {
+      role: "user",
+      content: `Your objective: ${objective}
+
+${context ? `Additional context:
+${JSON.stringify(context, null, 2)}` : ""}
+
+Please proceed with the task, reporting your progress as you go.`
+    }
+  ];
+  await addAgentMessage(agentId, {
+    role: "user",
+    content: messages[0].content
+  });
+  let stepNumber = 2;
+  const maxSteps = 20;
+  try {
+    while (stepNumber <= maxSteps) {
+      const stopCheck = await shouldAgentStop(agentId);
+      if (stopCheck.stop) {
+        await addAgentProgress(
+          agentId,
+          stepNumber,
+          `Stopping: ${stopCheck.reason}`,
+          "completed"
+        );
+        break;
+      }
+      const response = await anthropic.messages.create({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 4096,
+        system: systemPrompt,
+        tools: agentTools,
+        messages
+      });
+      totalTokensUsed += response.usage.input_tokens + response.usage.output_tokens;
+      await updateAgentTokens(agentId, totalTokensUsed);
+      if (totalTokensUsed >= tokenBudget) {
+        await addAgentProgress(
+          agentId,
+          stepNumber,
+          "Token budget reached",
+          "completed"
+        );
+        break;
+      }
+      const assistantContent = response.content;
+      const textContent = assistantContent.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      if (textContent) {
+        await addAgentMessage(agentId, {
+          role: "assistant",
+          content: textContent
+        });
+        const progressDesc = textContent.slice(0, 200).replace(/\n/g, " ");
+        await addAgentProgress(agentId, stepNumber, progressDesc, "running");
+      }
+      if (response.stop_reason === "end_turn") {
+        await addAgentProgress(
+          agentId,
+          stepNumber + 1,
+          "Task completed",
+          "completed",
+          textContent
+        );
+        return {
+          success: true,
+          output: textContent,
+          summary: extractSummary(textContent),
+          tokensUsed: totalTokensUsed,
+          durationMs: Date.now() - startTime
+        };
+      }
+      if (response.stop_reason === "tool_use") {
+        const toolResults = [];
+        for (const block of assistantContent) {
+          if (block.type === "tool_use") {
+            const toolName = block.name;
+            const toolInput = block.input;
+            console.log(`[Agent ${agentId}] Using tool: ${toolName}`);
+            const result = await executeTool(toolName, toolInput);
+            await addAgentMessage(agentId, {
+              role: "tool_result",
+              content: JSON.stringify({ tool: toolName, result }),
+              metadata: { toolInput }
+            });
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: block.id,
+              content: JSON.stringify(result)
+            });
+          }
+        }
+        messages.push({ role: "assistant", content: assistantContent });
+        messages.push({ role: "user", content: toolResults });
+      }
+      stepNumber++;
+    }
+    const agent = await getAgent(agentId);
+    const lastMessage = agent?.messages.slice(-1)[0]?.content || "";
+    return {
+      success: true,
+      output: lastMessage,
+      summary: "Agent completed maximum steps",
+      tokensUsed: totalTokensUsed,
+      durationMs: Date.now() - startTime
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await captureException(error, "agent", {
+      agentId,
+      type,
+      objective
+    }, userId);
+    await addAgentProgress(
+      agentId,
+      stepNumber,
+      `Error: ${errorMessage}`,
+      "failed"
+    );
+    return {
+      success: false,
+      error: errorMessage,
+      tokensUsed: totalTokensUsed,
+      durationMs: Date.now() - startTime
+    };
+  }
+}
+function buildSystemPrompt(type, context) {
+  let prompt = AGENT_SYSTEM_PROMPTS[type];
+  if (context) {
+    prompt += `
+
+Additional context about the user/task:
+${JSON.stringify(context, null, 2)}`;
+  }
+  return prompt;
+}
+function extractSummary(text) {
+  const summaryMatch = text.match(/(?:summary|conclusion|result):\s*(.+?)(?:\n\n|$)/i);
+  if (summaryMatch) {
+    return summaryMatch[1].trim();
+  }
+  const paragraphs = text.split("\n\n").filter((p) => p.trim());
+  return paragraphs.slice(-1)[0]?.slice(0, 500) || text.slice(0, 500);
+}
+function startAgentWorker() {
+  if (worker) return;
+  worker = new Worker(
+    "sentinel-agents",
+    async (job) => {
+      const result = await processAgentTask(job);
+      await updateAgentStatus(
+        job.data.agentId,
+        result.success ? "completed" : "failed",
+        result
+      );
+      metric.agentOperation("complete", job.data.type);
+      return result;
+    },
+    {
+      connection,
+      concurrency: 3
+      // Run up to 3 agents concurrently
+    }
+  );
+  worker.on("completed", (job) => {
+    console.log(`[AgentWorker] Agent completed: ${job.data.agentId}`);
+  });
+  worker.on("failed", (job, err) => {
+    console.error(`[AgentWorker] Agent failed: ${job?.data.agentId}`, err);
+  });
+  console.log("[AgentWorker] Agent worker started");
+}
+function stopAgentWorker() {
+  if (worker) {
+    worker.close();
+    worker = null;
+  }
+}
+
+// src/inputs/calendar/trigger-processor.ts
+import { eq as eq2 } from "drizzle-orm";
+
+// src/inputs/calendar/ical-parser.ts
+function getEventsInRange(events, start, end) {
+  return events.filter(
+    (event) => event.startDate >= start && event.startDate <= end
+  );
+}
+function getUpcomingEvents(events, count = 10) {
+  const now = /* @__PURE__ */ new Date();
+  return events.filter((event) => event.startDate >= now).slice(0, count);
+}
+function getTodaysEvents(events) {
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  const tomorrow = new Date(today);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  return getEventsInRange(events, today, tomorrow);
+}
+
+// src/inputs/calendar/trigger-processor.ts
+async function getUserTriggers(userId) {
+  const triggers = await db.select().from(calendarTriggers).where(eq2(calendarTriggers.userId, userId));
+  return triggers.map((t) => ({
+    id: t.id,
+    userId: t.userId,
+    name: t.name,
+    calendarSource: t.calendarSource,
+    calendarId: t.calendarId || void 0,
+    triggerType: t.triggerType,
+    offsetMinutes: t.offsetMinutes || 0,
+    action: t.action,
+    enabled: t.enabled ?? true
+  }));
+}
+async function processCalendarTriggers(userId, events, chatId) {
+  const triggers = await getUserTriggers(userId);
+  const enabledTriggers = triggers.filter((t) => t.enabled);
+  const results = [];
+  const now = Date.now();
+  for (const trigger of enabledTriggers) {
+    try {
+      if (trigger.triggerType === "daily_briefing") {
+        continue;
+      }
+      for (const event of events) {
+        const eventTime = trigger.triggerType === "event_start" ? event.startDate.getTime() : event.endDate.getTime();
+        const triggerTime = eventTime - trigger.offsetMinutes * 60 * 1e3;
+        if (triggerTime > now) {
+          const delay = triggerTime - now;
+          const jobId = await scheduleTask(
+            {
+              type: "custom",
+              message: formatTriggerMessage(trigger, event),
+              userId,
+              chatId
+            },
+            delay
+          );
+          results.push({
+            triggerId: trigger.id,
+            event,
+            scheduledJobId: jobId
+          });
+          await db.update(calendarTriggers).set({ lastTriggered: /* @__PURE__ */ new Date() }).where(eq2(calendarTriggers.id, trigger.id));
+        }
+      }
+    } catch (error) {
+      results.push({
+        triggerId: trigger.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function formatTriggerMessage(trigger, event) {
+  const timeStr = event.startDate.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+  if (trigger.triggerType === "event_start") {
+    if (trigger.offsetMinutes > 0) {
+      return `\u23F0 Reminder: "${event.summary}" starts in ${trigger.offsetMinutes} minutes at ${timeStr}`;
+    }
+    return `\u{1F514} "${event.summary}" is starting now!`;
+  }
+  if (trigger.triggerType === "event_end") {
+    return `\u2705 "${event.summary}" has ended`;
+  }
+  return `\u{1F4C5} Calendar event: ${event.summary}`;
+}
+async function generateDailyBriefing(userId, events) {
+  const todayEvents = getTodaysEvents(events);
+  const upcomingEvents = getUpcomingEvents(events, 5);
+  let briefing = "\u{1F4C5} **Your Daily Calendar Briefing**\n\n";
+  if (todayEvents.length === 0) {
+    briefing += "No events scheduled for today.\n\n";
+  } else {
+    briefing += `**Today's Events (${todayEvents.length}):**
+`;
+    for (const event of todayEvents) {
+      const timeStr = event.isAllDay ? "All day" : event.startDate.toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+      briefing += `\u2022 ${timeStr}: ${event.summary}`;
+      if (event.location) {
+        briefing += ` @ ${event.location}`;
+      }
+      briefing += "\n";
+    }
+    briefing += "\n";
+  }
+  const futureEvents = upcomingEvents.filter(
+    (e) => !todayEvents.some((t) => t.uid === e.uid)
+  );
+  if (futureEvents.length > 0) {
+    briefing += "**Upcoming:**\n";
+    for (const event of futureEvents.slice(0, 3)) {
+      const dateStr = event.startDate.toLocaleDateString([], {
+        weekday: "short",
+        month: "short",
+        day: "numeric"
+      });
+      briefing += `\u2022 ${dateStr}: ${event.summary}
+`;
+    }
+  }
+  return briefing;
+}
+
+// src/core/molt/memory-shedder.ts
+import { eq as eq3, and as and3, lt, lte as lte3 } from "drizzle-orm";
+var SHED_CONFIG = {
+  staleDays: 90,
+  // Memories not accessed in 90 days
+  lowImportanceThreshold: 3,
+  // Memories with importance <= 3
+  minConfidence: 70
+  // Minimum confidence to auto-shed
+};
+async function findStaleMemories(userId, staleDays = SHED_CONFIG.staleDays) {
+  const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1e3);
+  const stale = await db.select().from(memories).where(
+    and3(
+      eq3(memories.userId, userId),
+      lt(memories.lastAccessed, cutoff)
+    )
+  );
+  return stale.map((m) => ({
+    memoryId: m.id,
+    content: m.content,
+    type: m.type,
+    reason: "stale",
+    lastAccessed: m.lastAccessed,
+    importance: m.importance || 5,
+    confidence: calculateStaleConfidence(m.lastAccessed, m.importance || 5)
+  }));
+}
+function calculateStaleConfidence(lastAccessed, importance) {
+  if (!lastAccessed) return 80;
+  const daysSinceAccess = Math.floor(
+    (Date.now() - lastAccessed.getTime()) / (24 * 60 * 60 * 1e3)
+  );
+  let confidence = Math.min(daysSinceAccess / 2, 50);
+  confidence += (10 - importance) * 5;
+  return Math.min(confidence, 100);
+}
+async function findLowImportanceMemories(userId, threshold = SHED_CONFIG.lowImportanceThreshold) {
+  const lowImportance = await db.select().from(memories).where(
+    and3(
+      eq3(memories.userId, userId),
+      lte3(memories.importance, threshold)
+    )
+  );
+  return lowImportance.map((m) => ({
+    memoryId: m.id,
+    content: m.content,
+    type: m.type,
+    reason: "low_importance",
+    lastAccessed: m.lastAccessed,
+    importance: m.importance || 5,
+    confidence: (SHED_CONFIG.lowImportanceThreshold - (m.importance || 5) + 1) * 25
+  }));
+}
+async function findDuplicateMemories(userId) {
+  const allMemories = await db.select().from(memories).where(eq3(memories.userId, userId));
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const memory of allMemories) {
+    const normalized = memory.content.toLowerCase().trim();
+    const key = normalized.slice(0, 100);
+    const existing = seen.get(key);
+    if (existing) {
+      const isDuplicate = memory.createdAt > existing.createdAt ? memory : existing;
+      candidates.push({
+        memoryId: isDuplicate.id,
+        content: isDuplicate.content,
+        type: isDuplicate.type,
+        reason: "duplicate",
+        lastAccessed: isDuplicate.lastAccessed,
+        importance: isDuplicate.importance || 5,
+        confidence: 75
+        // Fairly confident about duplicates
+      });
+    } else {
+      seen.set(key, memory);
+    }
+  }
+  return candidates;
+}
+async function identifyShedCandidates(userId) {
+  const [stale, lowImportance, duplicates] = await Promise.all([
+    findStaleMemories(userId),
+    findLowImportanceMemories(userId),
+    findDuplicateMemories(userId)
+  ]);
+  const candidateMap = /* @__PURE__ */ new Map();
+  for (const candidate of [...stale, ...lowImportance, ...duplicates]) {
+    const existing = candidateMap.get(candidate.memoryId);
+    if (!existing || candidate.confidence > existing.confidence) {
+      candidateMap.set(candidate.memoryId, candidate);
+    }
+  }
+  return Array.from(candidateMap.values()).sort(
+    (a, b) => b.confidence - a.confidence
+  );
+}
+async function archiveMemory(memoryId, reason) {
+  const [memory] = await db.select().from(memories).where(eq3(memories.id, memoryId)).limit(1);
+  if (!memory) return false;
+  await db.insert(archivedMemories).values({
+    originalMemoryId: memory.id,
+    userId: memory.userId,
+    type: memory.type,
+    content: memory.content,
+    reason,
+    originalCreatedAt: memory.createdAt
+  });
+  await db.delete(memories).where(eq3(memories.id, memoryId));
+  return true;
+}
+async function autoShed(userId, minConfidence = SHED_CONFIG.minConfidence) {
+  const candidates = await identifyShedCandidates(userId);
+  const toArchive = candidates.filter((c) => c.confidence >= minConfidence);
+  const results = {
+    archivedCount: 0,
+    archivedIds: [],
+    skippedCount: 0
+  };
+  for (const candidate of toArchive) {
+    const success = await archiveMemory(candidate.memoryId, candidate.reason);
+    if (success) {
+      results.archivedCount++;
+      results.archivedIds.push(candidate.memoryId);
+    } else {
+      results.skippedCount++;
+    }
+  }
+  return results;
+}
+async function getArchivedMemories(userId, limit = 50) {
+  return db.select().from(archivedMemories).where(eq3(archivedMemories.userId, userId)).limit(limit);
+}
+async function getShedStats(userId) {
+  const archived = await getArchivedMemories(userId, 1e3);
+  const candidates = await identifyShedCandidates(userId);
+  const byReason = {
+    stale: 0,
+    duplicate: 0,
+    low_importance: 0,
+    user_request: 0,
+    deprecated_workflow: 0
+  };
+  for (const memory of archived) {
+    const reason = memory.reason;
+    if (reason in byReason) {
+      byReason[reason]++;
+    }
+  }
+  return {
+    totalArchived: archived.length,
+    byReason,
+    pendingCandidates: candidates.length
+  };
+}
+
+// src/core/molt/growth-reporter.ts
+async function generateWeeklyReport(userId) {
+  const endDate = /* @__PURE__ */ new Date();
+  const startDate = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3);
+  return generateReport(userId, startDate, endDate, "weekly");
+}
+async function generateMonthlyReport(userId) {
+  const endDate = /* @__PURE__ */ new Date();
+  const startDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
+  return generateReport(userId, startDate, endDate, "monthly");
+}
+async function generateReport(userId, startDate, endDate, type) {
+  const growthData = await generateGrowthReport(userId, startDate, endDate);
+  const newAchievements = await checkAchievements(userId);
+  const totalPoints = await getUserPoints(userId);
+  const modeStats = await getModeStats(userId);
+  const shedStats = await getShedStats(userId);
+  const highlights = generateHighlights(growthData, newAchievements);
+  const suggestions = await generateSuggestions(userId, growthData);
+  const summary = generateSummary(growthData, newAchievements, type);
+  return {
+    period: {
+      type,
+      start: startDate,
+      end: endDate
+    },
+    summary,
+    metrics: {
+      conversations: growthData.metrics.conversations,
+      messages: growthData.metrics.messages,
+      toolUses: growthData.metrics.toolUses,
+      newMemories: growthData.metrics.newMemories,
+      archivedMemories: shedStats.totalArchived
+    },
+    achievements: {
+      newlyUnlocked: newAchievements.map((a) => ({
+        name: a.name,
+        emoji: a.iconEmoji,
+        points: a.points
+      })),
+      totalPoints,
+      pointsGained: newAchievements.reduce((sum, a) => sum + a.points, 0)
+    },
+    modeUsage: {
+      productivity: modeStats.productivity,
+      creative: modeStats.creative,
+      research: modeStats.research,
+      learning: modeStats.learning
+    },
+    highlights,
+    suggestions
+  };
+}
+function generateHighlights(growthData, newAchievements) {
+  const highlights = [];
+  if (growthData.metrics.conversations > 0) {
+    highlights.push(
+      `You had ${growthData.metrics.conversations} conversations this period!`
+    );
+  }
+  if (growthData.metrics.toolUses > 10) {
+    highlights.push(
+      `Power user alert! You used tools ${growthData.metrics.toolUses} times.`
+    );
+  }
+  if (growthData.metrics.newMemories > 5) {
+    highlights.push(
+      `I learned ${growthData.metrics.newMemories} new things about you.`
+    );
+  }
+  for (const achievement of newAchievements) {
+    highlights.push(
+      `${achievement.iconEmoji} Achievement unlocked: ${achievement.name}!`
+    );
+  }
+  if (growthData.patterns.length > 0) {
+    const topPattern = growthData.patterns[0];
+    highlights.push(
+      `New pattern detected: You frequently use ${topPattern.key}.`
+    );
+  }
+  return highlights;
+}
+async function generateSuggestions(userId, growthData) {
+  const suggestions = [];
+  const progress = await getAchievementProgress(userId);
+  const almostUnlocked = progress.filter(
+    (p) => p.progress / p.target >= 0.7 && p.progress / p.target < 1
+  );
+  for (const achievement of almostUnlocked.slice(0, 2)) {
+    const remaining = achievement.target - achievement.progress;
+    suggestions.push(
+      `You're close to unlocking "${achievement.achievement.name}"! Just ${remaining} more ${achievement.achievement.criteria.metric}.`
+    );
+  }
+  const currentMode = await getCurrentMode(userId);
+  if (!currentMode) {
+    suggestions.push(
+      "Try activating a transformation mode! Say 'switch to productivity mode' to get started."
+    );
+  }
+  if (growthData.metrics.toolUses < 5) {
+    suggestions.push(
+      "You haven't used many tools this period. Try asking me to search the web, browse a page, or run a command!"
+    );
+  }
+  return suggestions;
+}
+function generateSummary(growthData, newAchievements, type) {
+  const period = type === "weekly" ? "this week" : "this month";
+  let summary = `Here's your ${type} growth report! `;
+  if (growthData.metrics.conversations > 0) {
+    summary += `You've been active with ${growthData.metrics.conversations} conversations ${period}. `;
+  } else {
+    summary += `I missed you ${period}! Let's catch up. `;
+  }
+  if (newAchievements.length > 0) {
+    summary += `You unlocked ${newAchievements.length} new achievement${newAchievements.length > 1 ? "s" : ""}! `;
+  }
+  if (growthData.metrics.newMemories > 0) {
+    summary += `I've been learning about you - ${growthData.metrics.newMemories} new memories stored. `;
+  }
+  return summary.trim();
+}
+
+// src/core/scheduler.ts
+var _connection = null;
+var _taskQueue = null;
+var _maintenanceQueue = null;
+function getConnection() {
+  if (!_connection) {
+    _connection = new Redis2(env.REDIS_URL, {
+      maxRetriesPerRequest: null
+    });
+  }
+  return _connection;
+}
+function getTaskQueue() {
+  if (!_taskQueue) {
+    _taskQueue = new Queue("sentinel-tasks", { connection: getConnection() });
+  }
+  return _taskQueue;
+}
+function getMaintenanceQueue() {
+  if (!_maintenanceQueue) {
+    _maintenanceQueue = new Queue("sentinel-maintenance", { connection: getConnection() });
+  }
+  return _maintenanceQueue;
+}
+var connection2 = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getConnection();
+    const value = instance[prop];
+    if (typeof value === "function") return value.bind(instance);
+    return value;
+  }
+});
+var taskQueue = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getTaskQueue();
+    const value = instance[prop];
+    if (typeof value === "function") return value.bind(instance);
+    return value;
+  }
+});
+var maintenanceQueue = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getMaintenanceQueue();
+    const value = instance[prop];
+    if (typeof value === "function") return value.bind(instance);
+    return value;
+  }
+});
+async function scheduleTask(task, delay) {
+  const job = await taskQueue.add("scheduled-task", task, {
+    delay,
+    removeOnComplete: true,
+    removeOnFail: 100
+  });
+  return job.id || "";
+}
+async function scheduleRecurring(name, task, pattern) {
+  await taskQueue.add(name, task, {
+    repeat: { pattern },
+    removeOnComplete: true
+  });
+}
+async function cancelTask(jobId) {
+  const job = await taskQueue.getJob(jobId);
+  if (job) {
+    await job.remove();
+    return true;
+  }
+  return false;
+}
+var worker2 = null;
+var maintenanceWorker = null;
+function startWorker(onTask) {
+  if (worker2) return;
+  worker2 = new Worker2(
+    "sentinel-tasks",
+    async (job) => {
+      console.log(`[Scheduler] Processing task: ${job.name}`);
+      await onTask(job.data);
+    },
+    { connection: getConnection() }
+  );
+  worker2.on("completed", (job) => {
+    console.log(`[Scheduler] Task completed: ${job.id}`);
+  });
+  worker2.on("failed", (job, err) => {
+    console.error(`[Scheduler] Task failed: ${job?.id}`, err);
+  });
+  console.log("[Scheduler] Worker started");
+}
+function startMaintenanceWorker() {
+  if (maintenanceWorker) return;
+  maintenanceWorker = new Worker2(
+    "sentinel-maintenance",
+    async (job) => {
+      console.log(`[Maintenance] Processing: ${job.name}`);
+      switch (job.data.type) {
+        case "calendar_check":
+          if (job.data.userId) {
+            await processCalendarTriggers(job.data.userId, []);
+          }
+          break;
+        case "memory_shed":
+          if (job.data.userId) {
+            const result = await autoShed(job.data.userId);
+            console.log(`[Maintenance] Memory shed: archived ${result.archivedCount} memories`);
+          }
+          break;
+        case "growth_report":
+          if (job.data.userId) {
+            const reportType = job.data.metadata?.reportType;
+            if (reportType === "monthly") {
+              await generateMonthlyReport(job.data.userId);
+            } else {
+              await generateWeeklyReport(job.data.userId);
+            }
+          }
+          break;
+        case "metrics_flush":
+          await flushMetrics();
+          break;
+        default:
+          console.log(`[Maintenance] Unknown task type: ${job.data.type}`);
+      }
+    },
+    { connection: getConnection() }
+  );
+  maintenanceWorker.on("completed", (job) => {
+    console.log(`[Maintenance] Completed: ${job.id}`);
+  });
+  maintenanceWorker.on("failed", (job, err) => {
+    console.error(`[Maintenance] Failed: ${job?.id}`, err);
+  });
+  console.log("[Maintenance] Worker started");
+}
+function stopWorker() {
+  if (worker2) {
+    worker2.close();
+    worker2 = null;
+  }
+}
+function stopMaintenanceWorker() {
+  if (maintenanceWorker) {
+    maintenanceWorker.close();
+    maintenanceWorker = null;
+  }
+}
+async function initializeScheduler(onTask) {
+  startWorker(onTask);
+  startMaintenanceWorker();
+  startAgentWorker();
+  await setupRecurringJobs();
+  console.log("[Scheduler] Initialized");
+}
+async function setupRecurringJobs() {
+  await maintenanceQueue.add(
+    "calendar-check",
+    { type: "calendar_check" },
+    {
+      repeat: { pattern: "*/15 * * * *" },
+      removeOnComplete: true
+    }
+  );
+  await maintenanceQueue.add(
+    "metrics-flush",
+    { type: "metrics_flush" },
+    {
+      repeat: { pattern: "*/5 * * * *" },
+      removeOnComplete: true
+    }
+  );
+  await maintenanceQueue.add(
+    "memory-shed-weekly",
+    { type: "memory_shed" },
+    {
+      repeat: { pattern: "0 3 * * 0" },
+      removeOnComplete: true
+    }
+  );
+  await maintenanceQueue.add(
+    "quota-reset-monthly",
+    { type: "custom", message: "quota_reset" },
+    {
+      repeat: { pattern: "0 0 1 * *" },
+      removeOnComplete: true
+    }
+  );
+  console.log("[Scheduler] Recurring jobs scheduled");
+}
+async function scheduleUserMaintenance(userId, type, options) {
+  const task = {
+    type,
+    userId,
+    metadata: options?.reportType ? { reportType: options.reportType } : void 0
+  };
+  if (options?.pattern) {
+    await maintenanceQueue.add(`${type}-${userId}`, task, {
+      repeat: { pattern: options.pattern },
+      removeOnComplete: true
+    });
+  } else {
+    await maintenanceQueue.add(`${type}-${userId}`, task, {
+      removeOnComplete: true
+    });
+  }
+}
+async function shutdownScheduler() {
+  stopWorker();
+  stopMaintenanceWorker();
+  stopAgentWorker();
+  if (_connection) await _connection.quit();
+  console.log("[Scheduler] Shutdown complete");
+}
+async function scheduleReminder(message, delayMs, chatId) {
+  return scheduleTask(
+    {
+      type: "reminder",
+      message,
+      chatId
+    },
+    delayMs
+  );
+}
+async function generateBriefing(userId) {
+  if (userId) {
+    try {
+      return await generateDailyBriefing(userId, []);
+    } catch {
+    }
+  }
+  const response = await chat(
+    [
+      {
+        role: "user",
+        content: `Generate a brief morning briefing. Include:
+1. A motivational greeting
+2. Today's date and day of week
+3. A productivity tip
+
+Keep it concise and uplifting.`
+      }
+    ],
+    "You are a helpful assistant creating a morning briefing."
+  );
+  return response.content;
+}
+async function getQueueStats() {
+  const [taskStats, maintenanceStats] = await Promise.all([
+    Promise.all([
+      taskQueue.getWaitingCount(),
+      taskQueue.getActiveCount(),
+      taskQueue.getCompletedCount(),
+      taskQueue.getFailedCount()
+    ]),
+    Promise.all([
+      maintenanceQueue.getWaitingCount(),
+      maintenanceQueue.getActiveCount(),
+      maintenanceQueue.getCompletedCount(),
+      maintenanceQueue.getFailedCount()
+    ])
+  ]);
+  return {
+    tasks: {
+      waiting: taskStats[0],
+      active: taskStats[1],
+      completed: taskStats[2],
+      failed: taskStats[3]
+    },
+    maintenance: {
+      waiting: maintenanceStats[0],
+      active: maintenanceStats[1],
+      completed: maintenanceStats[2],
+      failed: maintenanceStats[3]
+    }
+  };
+}
+
+export {
+  connection2 as connection,
+  taskQueue,
+  maintenanceQueue,
+  scheduleTask,
+  scheduleRecurring,
+  cancelTask,
+  startWorker,
+  startMaintenanceWorker,
+  stopWorker,
+  stopMaintenanceWorker,
+  initializeScheduler,
+  scheduleUserMaintenance,
+  shutdownScheduler,
+  scheduleReminder,
+  generateBriefing,
+  getQueueStats
+};
+//# sourceMappingURL=chunk-4LVWXUNC.js.map