@within-7/minto 0.4.2 → 0.4.3

package/dist/services/systemReminder.js

@@ -1,815 +0,0 @@
-import { homedir } from "os";
-import { getTodos } from "../utils/todoStorage.js";
-function escapeXml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-class SystemReminderService {
-  sessionState = {
-    lastTodoUpdate: 0,
-    lastFileAccess: 0,
-    sessionStartTime: Date.now(),
-    remindersSent: /* @__PURE__ */ new Set(),
-    contextPresent: false,
-    reminderCount: 0,
-    config: {
-      todoEmptyReminder: true,
-      securityReminder: true,
-      performanceReminder: true,
-      maxRemindersPerSession: 10
-    }
-  };
-  eventDispatcher = /* @__PURE__ */ new Map();
-  reminderCache = /* @__PURE__ */ new Map();
-  constructor() {
-    this.setupEventDispatcher();
-  }
-  /**
-   * Conditional reminder injection - only when context is present
-   * Enhanced with performance optimizations and priority management
-   */
-  generateReminders(hasContext = false, agentId) {
-    this.sessionState.contextPresent = hasContext;
-    if (!hasContext) {
-      return [];
-    }
-    if (this.sessionState.reminderCount >= this.sessionState.config.maxRemindersPerSession) {
-      return [];
-    }
-    const reminders = [];
-    const currentTime = Date.now();
-    if (this.sessionState.remindersSent.size > 100) {
-      this.pruneOldReminders(currentTime);
-    }
-    const reminderGenerators = [
-      () => this.getPlanModeActiveReminder(),
-      () => this.dispatchTodoEvent(agentId),
-      () => this.dispatchTaskToolsReminder(),
-      () => this.dispatchSecurityEvent(),
-      () => this.dispatchPerformanceEvent(),
-      () => this.getMentionReminders(),
-      () => this.getEventReminders(),
-      () => this.getTeamMessageReminders(agentId)
-    ];
-    for (const generator of reminderGenerators) {
-      if (reminders.length >= 8) break;
-      const result = generator();
-      if (result) {
-        const remindersToAdd = Array.isArray(result) ? result : [result];
-        reminders.push(...remindersToAdd);
-        this.sessionState.reminderCount += remindersToAdd.length;
-      }
-    }
-    return reminders;
-  }
-  /**
-   * Plan mode persistent reminder — injected EVERY turn while plan mode is active (CC behavior).
-   * Not gated by remindersSent because it must appear on every generateReminders() call.
-   */
-  getPlanModeActiveReminder() {
-    try {
-      const {
-        isPlanModeEnabled,
-        getPlanFilePath
-      } = require("../utils/plan/planMode");
-      if (!isPlanModeEnabled()) return null;
-      const planPath = getPlanFilePath();
-      return this.createReminderMessage(
-        "plan_mode_active",
-        "general",
-        "high",
-        `Plan mode is active. You MUST NOT make any edits or changes except to the plan file at: ${planPath}
-
-End every turn with either:
-- AskUserQuestion (to clarify requirements)
-- ExitPlanMode (to present your plan for approval)
-
-Do NOT write code, edit files, or run commands other than read-only exploration.`,
-        Date.now()
-      );
-    } catch {
-      return null;
-    }
-  }
-  dispatchTodoEvent(agentId) {
-    if (!this.sessionState.config.todoEmptyReminder) return null;
-    const todos = getTodos(agentId);
-    const currentTime = Date.now();
-    const agentKey = agentId || "default";
-    if (todos.length === 0 && !this.sessionState.remindersSent.has(`todo_empty_${agentKey}`)) {
-      this.sessionState.remindersSent.add(`todo_empty_${agentKey}`);
-      return this.createReminderMessage(
-        "todo",
-        "task",
-        "medium",
-        "This is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.",
-        currentTime
-      );
-    }
-    if (todos.length > 0) {
-      const reminderKey = `todo_updated_${agentKey}_${todos.length}_${this.getTodoStateHash(todos)}`;
-      if (this.reminderCache.has(reminderKey)) {
-        return this.reminderCache.get(reminderKey);
-      }
-      if (!this.sessionState.remindersSent.has(reminderKey)) {
-        this.sessionState.remindersSent.add(reminderKey);
-        this.clearTodoReminders(agentKey);
-        const todoContent = JSON.stringify(
-          todos.map((todo) => ({
-            content: todo.content.length > 100 ? todo.content.substring(0, 100) + "..." : todo.content,
-            status: todo.status,
-            priority: todo.priority,
-            id: todo.id
-          }))
-        );
-        const reminder = this.createReminderMessage(
-          "todo",
-          "task",
-          "medium",
-          `Your todo list has changed. DO NOT mention this explicitly to the user. Here are the latest contents of your todo list:
-
-${todoContent}. Continue on with the tasks at hand if applicable.`,
-          currentTime
-        );
-        this.reminderCache.set(reminderKey, reminder);
-        return reminder;
-      }
-    }
-    return null;
-  }
-  dispatchTaskToolsReminder() {
-    const key = "task_tools_reminder";
-    if (this.sessionState.remindersSent.has(key)) return null;
-    const sessionDuration = Date.now() - this.sessionState.sessionStartTime;
-    if (sessionDuration < 5 * 60 * 1e3) return null;
-    const hasTaskActivity = Array.from(this.sessionState.remindersSent).some(
-      (k) => k.startsWith("task_")
-    );
-    if (hasTaskActivity) return null;
-    this.emitEvent("task:tools_reminder", {});
-    return null;
-  }
-  dispatchSecurityEvent() {
-    if (!this.sessionState.config.securityReminder) return null;
-    const currentTime = Date.now();
-    if (this.sessionState.lastFileAccess > 0 && !this.sessionState.remindersSent.has("file_security")) {
-      this.sessionState.remindersSent.add("file_security");
-      return this.createReminderMessage(
-        "security",
-        "security",
-        "high",
-        "Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.",
-        currentTime
-      );
-    }
-    return null;
-  }
-  dispatchPerformanceEvent() {
-    if (!this.sessionState.config.performanceReminder) return null;
-    const currentTime = Date.now();
-    const sessionDuration = currentTime - this.sessionState.sessionStartTime;
-    if (sessionDuration > 30 * 60 * 1e3 && !this.sessionState.remindersSent.has("performance_long_session")) {
-      this.sessionState.remindersSent.add("performance_long_session");
-      return this.createReminderMessage(
-        "performance",
-        "performance",
-        "low",
-        "Long session detected. Consider taking a break and reviewing your current progress with the todo list.",
-        currentTime
-      );
-    }
-    return null;
-  }
-  /**
-   * Retrieve cached mention reminders
-   * Returns recent mentions (within 5 seconds) that haven't expired
-   */
-  getMentionReminders() {
-    const currentTime = Date.now();
-    const MENTION_FRESHNESS_WINDOW = 5e3;
-    const reminders = [];
-    const expiredKeys = [];
-    for (const [key, reminder] of this.reminderCache.entries()) {
-      if (this.isMentionReminder(reminder)) {
-        const age = currentTime - reminder.timestamp;
-        if (age <= MENTION_FRESHNESS_WINDOW) {
-          reminders.push(reminder);
-        } else {
-          expiredKeys.push(key);
-        }
-      }
-    }
-    expiredKeys.forEach((key) => this.reminderCache.delete(key));
-    return reminders;
-  }
-  /**
-   * Type guard for mention reminders - centralized type checking
-   * Eliminates hardcoded type strings scattered throughout the code
-   */
-  isMentionReminder(reminder) {
-    const mentionTypes = ["agent_mention", "file_mention", "ask_model_mention"];
-    return mentionTypes.includes(reminder.type);
-  }
-  /**
-   * Event-based reminder types for hook results, file status, task status
-   */
-  static EVENT_REMINDER_TYPES = /* @__PURE__ */ new Set([
-    // Batch A
-    "hook_additional_context",
-    "hook_blocking_error",
-    "hook_stopped_continuation",
-    "file_empty",
-    "file_truncated",
-    "task_status",
-    "task_tools_reminder",
-    // Batch B
-    "output_style_active",
-    "plan_file_reference",
-    "plan_mode_reentry",
-    "plan_exited",
-    "plan_verify",
-    "plan_mode_active",
-    "skill_invoked",
-    "mcp_resource_no_content",
-    "compact_file_reference",
-    // Batch C
-    "token_usage",
-    "budget_usd",
-    "team_coordination",
-    "team_shutdown",
-    "diagnostics_new",
-    "session_continuation"
-  ]);
-  isEventReminder(reminder) {
-    return SystemReminderService.EVENT_REMINDER_TYPES.has(reminder.type);
-  }
-  /**
-   * Retrieve cached event-based reminders (hook results, file status, task status)
-   * Returns recent event reminders within freshness window
-   */
-  getEventReminders() {
-    const currentTime = Date.now();
-    const EVENT_FRESHNESS_WINDOW = 1e4;
-    const reminders = [];
-    const expiredKeys = [];
-    for (const [key, reminder] of this.reminderCache.entries()) {
-      if (this.isEventReminder(reminder)) {
-        const age = currentTime - reminder.timestamp;
-        if (age <= EVENT_FRESHNESS_WINDOW) {
-          reminders.push(reminder);
-        } else {
-          expiredKeys.push(key);
-        }
-      }
-    }
-    expiredKeys.forEach((key) => this.reminderCache.delete(key));
-    return reminders;
-  }
-  /**
-   * Deliver pending team mailbox messages to the current agent as reminders.
-   * Checks unread messages for the agent's team-scoped ID and formats them
-   * as <team-message> blocks for conversation injection.
-   */
-  getTeamMessageReminders(agentId) {
-    if (!agentId) return null;
-    const teamName = process.env.MINTO_TEAM_NAME || agentId.split("@")[1];
-    if (!teamName) return null;
-    try {
-      const { getTeam } = require("./agentTeams/teamManager");
-      const entry = getTeam(teamName);
-      if (!entry) return null;
-      const { mailbox } = entry;
-      const unread = mailbox.getUnread(agentId);
-      if (unread.length === 0) return null;
-      mailbox.markRead(unread.map((m) => m.id));
-      const currentTime = Date.now();
-      const reminders = [];
-      for (const msg of unread) {
-        const senderName = msg.from.split("@")[0] || msg.from;
-        const summaryText = msg.summary || msg.text.slice(0, 60).replace(/"/g, "'");
-        const colorAttr = msg.color ? ` color="${escapeXml(msg.color)}"` : "";
-        const content = `<team-message from="${escapeXml(senderName)}"${colorAttr} summary="${escapeXml(summaryText)}">
-${escapeXml(msg.text)}
-</team-message>`;
-        reminders.push(
-          this.createReminderMessage(
-            "team_message",
-            "task",
-            "high",
-            content,
-            currentTime
-          )
-        );
-      }
-      return reminders;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Generate reminders for external file changes
-   * Called when todo files are modified externally
-   */
-  generateFileChangeReminder(context) {
-    const { agentId, filePath, reminder } = context;
-    if (!reminder) {
-      return null;
-    }
-    const currentTime = Date.now();
-    const reminderKey = `file_changed_${agentId}_${filePath}_${currentTime}`;
-    if (this.sessionState.remindersSent.has(reminderKey)) {
-      return null;
-    }
-    this.sessionState.remindersSent.add(reminderKey);
-    return this.createReminderMessage(
-      "file_changed",
-      "general",
-      "medium",
-      reminder,
-      currentTime
-    );
-  }
-  createReminderMessage(type, category, priority, content, timestamp) {
-    return {
-      role: "system",
-      content: `<system-reminder>
-${content}
-</system-reminder>`,
-      isMeta: true,
-      timestamp,
-      type,
-      priority,
-      category
-    };
-  }
-  getTodoStateHash(todos) {
-    return todos.map((t) => `${t.id}:${t.status}`).sort().join("|");
-  }
-  clearTodoReminders(agentId) {
-    const agentKey = agentId || "default";
-    for (const key of this.sessionState.remindersSent) {
-      if (key.startsWith(`todo_updated_${agentKey}_`)) {
-        this.sessionState.remindersSent.delete(key);
-      }
-    }
-  }
-  setupEventDispatcher() {
-    this.addEventListener("session:startup", (context) => {
-      this.resetSession();
-      this.sessionState.sessionStartTime = Date.now();
-      this.sessionState.contextPresent = Object.keys(context.context || {}).length > 0;
-    });
-    this.addEventListener("todo:changed", (context) => {
-      this.sessionState.lastTodoUpdate = Date.now();
-      this.clearTodoReminders(context.agentId);
-    });
-    this.addEventListener("todo:file_changed", (context) => {
-      const agentId = context.agentId || "default";
-      this.clearTodoReminders(agentId);
-      this.sessionState.lastTodoUpdate = Date.now();
-      const reminder = this.generateFileChangeReminder(context);
-      if (reminder) {
-        const cacheKey = `file_changed_${agentId}_${Date.now()}`;
-        this.reminderCache.set(cacheKey, reminder);
-      }
-    });
-    this.addEventListener("file:conflict", (context) => {
-      const filePath = context.filePath || context.path || "unknown";
-      const cacheKey = `file_conflict_${filePath}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(cacheKey)) {
-        this.sessionState.remindersSent.add(cacheKey);
-        const reminder = this.createReminderMessage(
-          "file_conflict",
-          "general",
-          "high",
-          `File ${filePath} was modified externally since last read. Re-read the file before editing to avoid overwriting changes.`,
-          Date.now()
-        );
-        this.reminderCache.set(cacheKey, reminder);
-      }
-    });
-    this.addEventListener("file:read", (context) => {
-      this.sessionState.lastFileAccess = Date.now();
-    });
-    this.addEventListener("file:edited", (context) => {
-    });
-    this.addEventListener("agent:mentioned", (context) => {
-      this.createMentionReminder({
-        type: "agent_mention",
-        key: `agent_mention_${context.agentType}_${context.timestamp}`,
-        category: "task",
-        priority: "high",
-        content: `The user mentioned @${context.originalMention}. You MUST use the Task tool with subagent_type="${context.agentType}" to delegate this task to the specified agent. Provide a detailed, self-contained task description that fully captures the user's intent for the ${context.agentType} agent to execute.`,
-        timestamp: context.timestamp
-      });
-    });
-    this.addEventListener("file:mentioned", (context) => {
-      this.createMentionReminder({
-        type: "file_mention",
-        key: `file_mention_${context.filePath}_${context.timestamp}`,
-        category: "general",
-        priority: "high",
-        content: `The user mentioned @${context.originalMention}. You MUST read the entire content of the file at path: ${context.filePath} using the Read tool to understand the full context before proceeding with the user's request.`,
-        timestamp: context.timestamp
-      });
-    });
-    this.addEventListener("ask-model:mentioned", (context) => {
-      this.createMentionReminder({
-        type: "ask_model_mention",
-        key: `ask_model_mention_${context.modelName}_${context.timestamp}`,
-        category: "task",
-        priority: "high",
-        content: `The user mentioned @${context.modelName}. You MUST use the AskExpertModelTool to consult this specific model for expert opinions and analysis. Provide the user's question or context clearly to get the most relevant response from ${context.modelName}.`,
-        timestamp: context.timestamp
-      });
-    });
-    this.addEventListener("hook:additional_context", (context) => {
-      const key = `hook_ctx_${context.hookName}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "hook_additional_context",
-          "general",
-          "medium",
-          `Additional context from hook "${escapeXml(context.hookName)}": ${escapeXml(String(context.content))}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("hook:blocking_error", (context) => {
-      const key = `hook_block_${context.hookName}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "hook_blocking_error",
-          "general",
-          "high",
-          `A hook blocked the action: ${escapeXml(String(context.reason))}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("hook:stopped_continuation", (context) => {
-      const key = `hook_stop_${context.hookName}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "hook_stopped_continuation",
-          "general",
-          "high",
-          `A hook stopped continuation: ${escapeXml(String(context.reason))}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("file:empty", (context) => {
-      const key = `file_empty_${context.filePath}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "file_empty",
-          "general",
-          "low",
-          `File exists but is empty: ${context.filePath}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("file:truncated", (context) => {
-      const key = `file_truncated_${context.filePath}_${context.limit}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "file_truncated",
-          "general",
-          "low",
-          `File content was truncated at ${context.limit} lines. Total lines: ${context.totalLines}. Use offset and limit to read more.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("task:status", (context) => {
-      const key = `task_status_${context.taskId}_${context.status}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "task_status",
-          "task",
-          "medium",
-          `Task ${context.taskId} (${context.description || "unnamed"}): status changed to ${context.status}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("task:tools_reminder", (context) => {
-      const key = "task_tools_reminder";
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "task_tools_reminder",
-          "task",
-          "low",
-          "The task tools haven't been used recently. If you're working on tasks that would benefit from tracking progress, consider using TaskCreate to add new tasks and TaskUpdate to update task status (set to in_progress when starting, completed when done). Also consider cleaning up the task list if it has become stale. Only use these if relevant to the current work. This is just a gentle reminder - ignore if not applicable. Make sure that you NEVER mention this reminder to the user",
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("output_style:active", (context) => {
-      const key = `output_style_active_${context.styleName}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "output_style_active",
-          "general",
-          "low",
-          `Output style "${context.styleName}" is active. Follow its formatting instructions for your responses.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("plan:file_reference", (context) => {
-      const key = `plan_file_ref_${context.planPath}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "plan_file_reference",
-          "general",
-          "medium",
-          `A plan file exists at: ${context.planPath}. Review it before making implementation decisions.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("plan:mode_reentry", (context) => {
-      const key = `plan_reentry_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "plan_mode_reentry",
-          "general",
-          "medium",
-          "Re-entering plan mode. Review the existing plan and update as needed before implementation.",
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("plan:exited", (context) => {
-      const key = `plan_exited_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "plan_exited",
-          "general",
-          "medium",
-          "Exited plan mode. Proceed with implementation following the approved plan.",
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("skill:invoked", (context) => {
-      const key = `skill_invoked_${context.skillName}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "skill_invoked",
-          "general",
-          "low",
-          `Skill "${context.skillName}" was invoked. Follow the skill's instructions in the expanded prompt.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("mcp:resource_no_content", (context) => {
-      const key = `mcp_no_content_${context.resourceUri}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "mcp_resource_no_content",
-          "general",
-          "low",
-          `MCP resource "${context.resourceUri}" returned no content. It may be unavailable or empty.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("compact:file_reference", (context) => {
-      const key = `compact_file_ref_${context.filePath}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "compact_file_reference",
-          "general",
-          "low",
-          `Note: ${context.filePath} was read before the last conversation was summarized, but the contents are too large to include. Use Read tool if you need to access it.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("plan:verify", (context) => {
-      const key = `plan_verify_${context.planPath}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "plan_verify",
-          "general",
-          "medium",
-          `Implementation is complete. Verify against the approved plan at: ${context.planPath}. Check that all planned changes were made, run tests, and confirm the verification procedures from the plan pass.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("token:usage", (context) => {
-      const key = `token_usage_${context.threshold}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "token_usage",
-          "performance",
-          "low",
-          `Token usage has reached ${context.percentage}% of context limit (${context.used}/${context.total} tokens).`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("budget:usd", (context) => {
-      const key = `budget_usd_${context.threshold}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "budget_usd",
-          "performance",
-          "medium",
-          `USD budget usage: $${context.used.toFixed(2)} of $${context.limit.toFixed(2)} (${context.percentage}%).`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("team:coordination", (context) => {
-      const key = `team_coord_${context.teamId}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const teamId = context.teamId;
-        const homeDir = homedir();
-        const teamConfigPath = `${homeDir}/.minto/teams/${teamId}/config.json`;
-        const taskListPath = `${homeDir}/.minto/tasks/${teamId}`;
-        const reminder = this.createReminderMessage(
-          "team_coordination",
-          "task",
-          "medium",
-          `Team coordination: ${context.message}
-teamConfigPath: ${teamConfigPath}
-taskListPath: ${taskListPath}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("team:shutdown", (context) => {
-      const key = `team_shutdown_${context.teamId}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "team_shutdown",
-          "task",
-          "high",
-          `Team "${context.teamId}" is shutting down. Reason: ${context.reason || "completed"}`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("diagnostics:new", (context) => {
-      const key = `diagnostics_${context.source}_${Date.now()}`;
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const count = context.count || 1;
-        const reminder = this.createReminderMessage(
-          "diagnostics_new",
-          "general",
-          "low",
-          `${count} new diagnostic${count > 1 ? "s" : ""} detected from ${context.source}. Review before proceeding.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-    this.addEventListener("session:continuation", (context) => {
-      const key = "session_continuation";
-      if (!this.sessionState.remindersSent.has(key)) {
-        this.sessionState.remindersSent.add(key);
-        const reminder = this.createReminderMessage(
-          "session_continuation",
-          "general",
-          "medium",
-          `This session is a continuation of a previous conversation. Key context has been preserved.`,
-          Date.now()
-        );
-        this.reminderCache.set(key, reminder);
-      }
-    });
-  }
-  addEventListener(event, callback) {
-    if (!this.eventDispatcher.has(event)) {
-      this.eventDispatcher.set(event, []);
-    }
-    this.eventDispatcher.get(event).push(callback);
-  }
-  emitEvent(event, context) {
-    const listeners = this.eventDispatcher.get(event) || [];
-    listeners.forEach((callback) => {
-      try {
-        callback(context);
-      } catch (error) {
-        console.error(`Error in event listener for ${event}:`, error);
-      }
-    });
-  }
-  /**
-   * Unified mention reminder creation - eliminates duplicate logic
-   * Centralizes reminder creation with consistent deduplication
-   */
-  createMentionReminder(params) {
-    if (!this.sessionState.remindersSent.has(params.key)) {
-      this.sessionState.remindersSent.add(params.key);
-      const reminder = this.createReminderMessage(
-        params.type,
-        params.category,
-        params.priority,
-        params.content,
-        params.timestamp
-      );
-      this.reminderCache.set(params.key, reminder);
-    }
-  }
-  /**
-   * Prune old reminder keys to prevent unbounded Set growth.
-   * Keeps keys that contain timestamps or are "sticky" (security, performance).
-   * Removes generic keys when the set exceeds threshold.
-   */
-  pruneOldReminders(_currentTime) {
-    const stickyPrefixes = ["file_security", "performance_", "todo_empty_"];
-    const toDelete = [];
-    for (const key of this.sessionState.remindersSent) {
-      if (!stickyPrefixes.some((p) => key.startsWith(p))) {
-        toDelete.push(key);
-      }
-    }
-    const removeCount = Math.min(
-      toDelete.length,
-      Math.floor(toDelete.length / 2)
-    );
-    for (let i = 0; i < removeCount; i++) {
-      this.sessionState.remindersSent.delete(toDelete[i]);
-    }
-  }
-  resetSession() {
-    this.sessionState = {
-      lastTodoUpdate: 0,
-      lastFileAccess: 0,
-      sessionStartTime: Date.now(),
-      remindersSent: /* @__PURE__ */ new Set(),
-      contextPresent: false,
-      reminderCount: 0,
-      config: { ...this.sessionState.config }
-      // Preserve config across resets
-    };
-    this.reminderCache.clear();
-  }
-  updateConfig(config) {
-    this.sessionState.config = { ...this.sessionState.config, ...config };
-  }
-  getSessionState() {
-    return { ...this.sessionState };
-  }
-}
-const systemReminderService = new SystemReminderService();
-const generateSystemReminders = (hasContext = false, agentId) => systemReminderService.generateReminders(hasContext, agentId);
-const generateFileChangeReminder = (context) => systemReminderService.generateFileChangeReminder(context);
-const emitReminderEvent = (event, context) => systemReminderService.emitEvent(event, context);
-const resetReminderSession = () => systemReminderService.resetSession();
-const getReminderSessionState = () => systemReminderService.getSessionState();
-export {
-  emitReminderEvent,
-  generateFileChangeReminder,
-  generateSystemReminders,
-  getReminderSessionState,
-  resetReminderSession,
-  systemReminderService
-};
-//# sourceMappingURL=systemReminder.js.map