pybao-cli 1.4.50 → 1.4.52

package/dist/{chunk-XCXUN4XC.js → chunk-4LMBJZXO.js}

@@ -2,7 +2,7 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   getSessionProjectDir
-} from "./chunk-AC5SOSXY.js";
+} from "./chunk-RCASKKDU.js";
 import {
   isUuid
 } from "./chunk-5P7HBXTD.js";

package/dist/{chunk-E3U4MTTG.js → chunk-BRKYVW3X.js}

@@ -8,14 +8,14 @@ import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   saveSettingsToPrimaryAndSyncLegacy
-} from "./chunk-SKHJKLQU.js";
+} from "./chunk-R3QXCIEI.js";
 import {
   getCurrentProjectConfig
-} from "./chunk-JS7GLW6B.js";
+} from "./chunk-KFQPMAFO.js";
 import {
   getCwd,
   logError
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 
 // src/utils/permissions/toolPermissionSettings.ts
 function uniqueStrings(value) {

package/dist/{chunk-QMS564WP.js → chunk-CACSIWAN.js}

@@ -3,7 +3,7 @@ const require = __pybCreateRequire(import.meta.url);
 import {
   SESSION_ID,
   resolveXdgCachePath
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 
 // src/utils/log/debugLogger.ts
 import { existsSync, mkdirSync, appendFileSync } from "fs";

package/dist/{chunk-O57TU7BN.js → chunk-CIPSRLKQ.js}

@@ -448,7 +448,7 @@ function getLastAssistantMessageId(messages) {
 
 // src/utils/messages/index.ts
 async function processUserInput(input, mode, setToolJSX, context, pastedImages) {
-  const impl = await import("./userInput-XNKXJX2C.js");
+  const impl = await import("./userInput-IZB262ZP.js");
   return impl.processUserInput(input, mode, setToolJSX, context, pastedImages);
 }
 

package/dist/{chunk-AB22WTOW.js → chunk-DWNHYJME.js}

@@ -3,13 +3,13 @@ const require = __pybCreateRequire(import.meta.url);
 import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback
-} from "./chunk-SKHJKLQU.js";
+} from "./chunk-R3QXCIEI.js";
 import {
   getSessionPlugins
 } from "./chunk-BJSWTHRM.js";
 import {
   getTheme
-} from "./chunk-F4YDJQRG.js";
+} from "./chunk-FTYUYN6L.js";
 import {
   addMcprcServerForTesting,
   getCurrentProjectConfig,
@@ -19,13 +19,13 @@ import {
   safeParseJSON,
   saveCurrentProjectConfig,
   saveGlobalConfig
-} from "./chunk-JS7GLW6B.js";
+} from "./chunk-KFQPMAFO.js";
 import {
   PRODUCT_COMMAND,
   PRODUCT_NAME,
   getCwd,
   logMCPError
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 
 // src/services/mcp/client.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";

package/dist/{chunk-VRJYDMPZ.js → chunk-EBSC7C7P.js}

@@ -4,10 +4,10 @@ import {
   PRODUCT_NAME,
   execFileNoThrow,
   logError
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 import {
   MACRO
-} from "./chunk-7FPCY7TP.js";
+} from "./chunk-NCHARDNR.js";
 
 // src/utils/session/autoUpdater.ts
 async function getSemver() {
@@ -82,7 +82,7 @@ async function checkAndNotifyUpdate() {
     const [
       { isAutoUpdaterDisabled, getGlobalConfig, saveGlobalConfig },
       { env }
-    ] = await Promise.all([import("./config-VXOZS327.js"), import("./env-6I7ZEE2U.js")]);
+    ] = await Promise.all([import("./config-AGAJCFQD.js"), import("./env-RPUIAXPD.js")]);
     if (await isAutoUpdaterDisabled()) return;
     if (await env.getIsDocker()) return;
     if (!await env.hasInternetAccess()) return;

package/dist/{chunk-K7HQMRMK.js → chunk-EF6YCOC4.js}

@@ -3,7 +3,7 @@ const require = __pybCreateRequire(import.meta.url);
 
 // src/services/ai/llmLazy.ts
 async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const { queryLLM: inner } = await import("./llm-XKWTYXNE.js");
+  const { queryLLM: inner } = await import("./llm-CP2G3BZQ.js");
   return inner(
     messages,
     systemPrompt,
@@ -14,15 +14,15 @@ async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal
   );
 }
 async function queryQuick(args) {
-  const { queryQuick: inner } = await import("./llm-XKWTYXNE.js");
+  const { queryQuick: inner } = await import("./llm-CP2G3BZQ.js");
   return inner(args);
 }
 async function verifyApiKey(apiKey, baseURL, provider) {
-  const { verifyApiKey: inner } = await import("./llm-XKWTYXNE.js");
+  const { verifyApiKey: inner } = await import("./llm-CP2G3BZQ.js");
   return inner(apiKey, baseURL, provider);
 }
 async function fetchAnthropicModels(apiKey, baseURL) {
-  const { fetchAnthropicModels: inner } = await import("./llm-XKWTYXNE.js");
+  const { fetchAnthropicModels: inner } = await import("./llm-CP2G3BZQ.js");
   return inner(apiKey, baseURL);
 }
 

package/dist/{chunk-F4YDJQRG.js → chunk-FTYUYN6L.js}

@@ -2,7 +2,7 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   getGlobalConfig
-} from "./chunk-JS7GLW6B.js";
+} from "./chunk-KFQPMAFO.js";
 
 // src/utils/theme/index.ts
 var lightTheme = {

package/dist/{chunk-2QE4GPBW.js → chunk-FVNXJG2K.js}

@@ -7,14 +7,14 @@ import {
   getSettingsFileCandidates,
   loadSettingsWithLegacyFallback,
   saveSettingsToPrimaryAndSyncLegacy
-} from "./chunk-SKHJKLQU.js";
+} from "./chunk-R3QXCIEI.js";
 import {
   getSessionPlugins
 } from "./chunk-BJSWTHRM.js";
 import {
   getCwd,
   getXdgConfigDir
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 
 // src/services/ui/outputStyles.ts
 import figures from "figures";

package/dist/{chunk-XPPMTVLO.js → chunk-GFD2DNDU.js}

@@ -2,11 +2,11 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   listAllContentFiles
-} from "./chunk-DY6LXTDU.js";
+} from "./chunk-VSGJTKCW.js";
 import {
   getCwd,
   logError
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 
 // src/utils/fs/file.ts
 import {

package/dist/{chunk-EJEYT52K.js → chunk-H6QOGXMT.js}

@@ -2,15 +2,15 @@ import { createRequire as __pybCreateRequire } from "node:module";
 const require = __pybCreateRequire(import.meta.url);
 import {
   loadSettingsWithLegacyFallback
-} from "./chunk-SKHJKLQU.js";
+} from "./chunk-R3QXCIEI.js";
 import {
   debug
-} from "./chunk-QMS564WP.js";
+} from "./chunk-CACSIWAN.js";
 import {
   env,
   getSessionRoot,
   resolveXdgDataPath
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 import {
   __require
 } from "./chunk-I3J4JYES.js";

package/dist/{chunk-JS7GLW6B.js → chunk-KFQPMAFO.js}

@@ -5,13 +5,13 @@ import {
 } from "./chunk-RQVLBMP7.js";
 import {
   debug
-} from "./chunk-QMS564WP.js";
+} from "./chunk-CACSIWAN.js";
 import {
   getCwd,
   getGlobalConfigFilePath,
   getLegacyGlobalConfigFilePath,
   logError
-} from "./chunk-XY7UAZHR.js";
+} from "./chunk-LHL4VQUV.js";
 
 // src/core/config/schema.ts
 function isAutoUpdaterStatus(value) {
@@ -688,7 +688,7 @@ function setModelPointer(pointer, modelName) {
     }
   };
   saveGlobalConfig(updatedConfig);
-  import("./model-XS54COOK.js").then(({ reloadModelManager }) => {
+  import("./model-OMBFATWA.js").then(({ reloadModelManager }) => {
     reloadModelManager();
   });
 }

package/dist/chunk-KMM3X3B5.js

@@ -0,0 +1,448 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  debug
+} from "./chunk-CACSIWAN.js";
+import {
+  logError
+} from "./chunk-LHL4VQUV.js";
+
+// src/services/system/systemReminder.ts
+var SystemReminderService = class {
+  sessionState = {
+    lastFileAccess: 0,
+    lastTaskUpdate: 0,
+    sessionStartTime: Date.now(),
+    remindersSent: /* @__PURE__ */ new Set(),
+    contextPresent: false,
+    reminderCount: 0,
+    taskEventTimestamps: /* @__PURE__ */ new Map(),
+    config: {
+      securityReminder: true,
+      performanceReminder: true,
+      maxRemindersPerSession: 10
+    }
+  };
+  eventDispatcher = /* @__PURE__ */ new Map();
+  reminderCache = /* @__PURE__ */ new Map();
+  constructor() {
+    this.setupEventDispatcher();
+  }
+  generateReminders(hasContext = false, _agentId) {
+    this.sessionState.contextPresent = hasContext;
+    if (!hasContext) {
+      return [];
+    }
+    if (this.sessionState.reminderCount >= this.sessionState.config.maxRemindersPerSession) {
+      return [];
+    }
+    const reminders = [];
+    const reminderGenerators = [
+      () => this.dispatchSecurityEvent(),
+      () => this.dispatchPerformanceEvent(),
+      () => this.getMentionReminders()
+    ];
+    for (const generator of reminderGenerators) {
+      if (reminders.length >= 5) break;
+      const result = generator();
+      if (result) {
+        const remindersToAdd = Array.isArray(result) ? result : [result];
+        reminders.push(...remindersToAdd);
+        this.sessionState.reminderCount += remindersToAdd.length;
+      }
+    }
+    return reminders;
+  }
+  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 task list.",
+        currentTime
+      );
+    }
+    return null;
+  }
+  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;
+  }
+  isMentionReminder(reminder) {
+    const mentionTypes = ["agent_mention", "file_mention", "ask_model_mention"];
+    return mentionTypes.includes(reminder.type);
+  }
+  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
+    };
+  }
+  shouldEmitTaskReminder(key, throttleMs) {
+    const now = Date.now();
+    const last = this.sessionState.taskEventTimestamps.get(key) ?? 0;
+    if (now - last < throttleMs) {
+      return false;
+    }
+    this.sessionState.taskEventTimestamps.set(key, now);
+    return true;
+  }
+  createTaskListReminder(context) {
+    const { listId, summary } = context;
+    if (!summary || !listId) return null;
+    const reminderKey = `task_list_${listId}_${summary.total}_${summary.ready}_${summary.blocked}_${summary.inProgress}_${summary.pending}_${summary.done}_${summary.archived}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    return this.createReminderMessage(
+      "task_list_changed",
+      "task",
+      "medium",
+      `Your task list changed. Ready: ${summary.ready}, Blocked: ${summary.blocked}, In progress: ${summary.inProgress}, Pending: ${summary.pending}, Done: ${summary.done}, Archived: ${summary.archived}.`,
+      Date.now()
+    );
+  }
+  createTaskReadyReminder(context) {
+    const { listId, readyIds } = context;
+    if (!listId || !Array.isArray(readyIds)) return null;
+    const limited = readyIds.slice(0, 5).join(", ");
+    const reminderKey = `task_ready_${listId}_${readyIds.length}_${limited}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    return this.createReminderMessage(
+      "task_ready_changed",
+      "task",
+      "medium",
+      `Task readiness changed. Ready count: ${readyIds.length}. Ready ids: ${limited || "none"}.`,
+      Date.now()
+    );
+  }
+  createTaskConflictReminder(context) {
+    const { listId, taskId } = context;
+    if (!listId || !taskId) return null;
+    const reminderKey = `task_conflict_${listId}_${taskId}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    return this.createReminderMessage(
+      "task_conflict",
+      "task",
+      "high",
+      `Task update conflict detected for ${taskId}. Refresh task data and retry updates with the latest baseVersion.`,
+      Date.now()
+    );
+  }
+  createTaskCreatedReminder(context) {
+    const { listId, taskId, task } = context;
+    if (!listId || !taskId) return null;
+    const reminderKey = `task_created_${listId}_${taskId}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    const subject = task?.subject || taskId;
+    return this.createReminderMessage(
+      "task_created",
+      "task",
+      "medium",
+      `Task created: ${subject} (${taskId}). Review details and adjust status if needed.`,
+      Date.now()
+    );
+  }
+  createTaskUpdatedReminder(context) {
+    const { listId, taskId, task } = context;
+    if (!listId || !taskId) return null;
+    const reminderKey = `task_updated_${listId}_${taskId}_${task?.baseVersion ?? ""}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    const subject = task?.subject || taskId;
+    return this.createReminderMessage(
+      "task_updated",
+      "task",
+      "medium",
+      `Task updated: ${subject} (${taskId}). Confirm dependencies and status are correct.`,
+      Date.now()
+    );
+  }
+  createTaskStatusReminder(context) {
+    const { listId, taskId, previousStatus, status } = context;
+    if (!listId || !taskId) return null;
+    const reminderKey = `task_status_${listId}_${taskId}_${previousStatus}_${status}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    return this.createReminderMessage(
+      "task_status_changed",
+      "task",
+      "medium",
+      `Task status changed for ${taskId}: ${previousStatus} \u2192 ${status}. Review dependent tasks if needed.`,
+      Date.now()
+    );
+  }
+  createTaskDepsReminder(context) {
+    const { listId, taskId, deps } = context;
+    if (!listId || !taskId) return null;
+    const reminderKey = `task_deps_${listId}_${taskId}_${JSON.stringify(deps ?? {})}`;
+    if (this.sessionState.remindersSent.has(reminderKey)) return null;
+    this.sessionState.remindersSent.add(reminderKey);
+    return this.createReminderMessage(
+      "task_deps_changed",
+      "task",
+      "medium",
+      `Task dependencies changed for ${taskId}. Recheck readiness and blockers.`,
+      Date.now()
+    );
+  }
+  setupEventDispatcher() {
+    this.addEventListener("session:startup", (context) => {
+      this.resetSession();
+      this.sessionState.sessionStartTime = Date.now();
+      this.sessionState.contextPresent = Object.keys(context.context || {}).length > 0;
+    });
+    this.addEventListener("task:list_changed", (context) => {
+      const key = `task_list_${context.listId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      this.sessionState.lastTaskUpdate = Date.now();
+      const reminder = this.createTaskListReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: "task_list_changed",
+          timestamp: Date.now()
+        });
+      }
+    });
+    this.addEventListener("task:ready_changed", (context) => {
+      const key = `task_ready_${context.listId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      const reminder = this.createTaskReadyReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: "task_ready_changed",
+          timestamp: Date.now()
+        });
+      }
+    });
+    this.addEventListener("task:conflict_detected", (context) => {
+      const key = `task_conflict_${context.listId}_${context.taskId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      const reminder = this.createTaskConflictReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: "task_conflict",
+          timestamp: Date.now()
+        });
+      }
+    });
+    this.addEventListener("task.created", (context) => {
+      const key = `task_created_${context.listId}_${context.taskId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      const reminder = this.createTaskCreatedReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: reminder.type,
+          timestamp: reminder.timestamp
+        });
+      }
+    });
+    this.addEventListener("task.updated", (context) => {
+      const key = `task_updated_${context.listId}_${context.taskId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      const reminder = this.createTaskUpdatedReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: reminder.type,
+          timestamp: reminder.timestamp
+        });
+      }
+    });
+    this.addEventListener("task.status_changed", (context) => {
+      const key = `task_status_${context.listId}_${context.taskId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      const reminder = this.createTaskStatusReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: reminder.type,
+          timestamp: reminder.timestamp
+        });
+      }
+    });
+    this.addEventListener("task.deps_changed", (context) => {
+      const key = `task_deps_${context.listId}_${context.taskId}`;
+      if (!this.shouldEmitTaskReminder(key, 2e3)) return;
+      const reminder = this.createTaskDepsReminder(context);
+      if (reminder) {
+        this.emitEvent("reminder:inject", {
+          reminder: reminder.content,
+          listId: context.listId,
+          type: reminder.type,
+          timestamp: reminder.timestamp
+        });
+      }
+    });
+    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
+      });
+    });
+  }
+  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) {
+        logError(error);
+        debug.warn("SYSTEM_REMINDER_LISTENER_ERROR", {
+          event,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+  }
+  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);
+    }
+  }
+  resetSession() {
+    this.sessionState = {
+      lastFileAccess: 0,
+      lastTaskUpdate: 0,
+      sessionStartTime: Date.now(),
+      remindersSent: /* @__PURE__ */ new Set(),
+      contextPresent: false,
+      reminderCount: 0,
+      taskEventTimestamps: /* @__PURE__ */ new Map(),
+      config: { ...this.sessionState.config }
+    };
+    this.reminderCache.clear();
+  }
+  updateConfig(config) {
+    this.sessionState.config = { ...this.sessionState.config, ...config };
+  }
+  getSessionState() {
+    return { ...this.sessionState };
+  }
+};
+var systemReminderService = new SystemReminderService();
+var generateSystemReminders = (hasContext = false, agentId) => systemReminderService.generateReminders(hasContext, agentId);
+var emitReminderEvent = (event, context) => systemReminderService.emitEvent(event, context);
+var resetReminderSession = () => systemReminderService.resetSession();
+
+export {
+  systemReminderService,
+  generateSystemReminders,
+  emitReminderEvent,
+  resetReminderSession
+};