ofiere-openclaw-plugin 4.56.5 → 4.56.6

package/dist/src/tools.js

@@ -254,6 +254,7 @@ function registerTaskOps(api, supabase, userId, resolveAgent, timezone) {
             `  • "every N weeks"   → recurrence_type:"weekly"   + recurrence_interval:N\n` +
             `  • "every N months"  → recurrence_type:"monthly"  + recurrence_interval:N\n` +
             `🛑 NEVER use daily+1 (or hourly+24, etc.) when the user said a minute-level cadence — the task will fire ONCE per 24h instead of every N minutes. This was a real prod bug (v1 smoke 2026-05-17).\n` +
+            `🚦 BURST GUARD (Fix #3, 2026-05-17): when you create >3 recurring tasks within 60s for the same user, the server auto-staggers each new task's first fire by (count × min(recurrence_interval_secs, 1800)) so 6+ tasks with a shared T0 anchor do NOT all burst on the same pg_cron tick. Pass distinct start_date values per task if you need precise first-fire times.\n` +
             `\n` +
             `Approvals: Use add_approval to request sign-off from humans or agents. Approvals are separate from workflow gate nodes.\n` +
             `Status: PENDING, IN_PROGRESS, DONE, FAILED | Priority: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL`,
@@ -593,6 +594,21 @@ function humanizeCadence(type, interval) {
     const unit = unitMap[type] || type;
     return interval === 1 ? `every ${unit}` : `every ${interval} ${unit}s`;
 }
+// Fix #3 (2026-05-17): bulk-create stagger helper. Maps recurrence_type +
+// interval to cadence in seconds; used to compute the per-slot offset
+// applied when a user bulk-creates >3 recurring scheduler_events within a
+// 60s window (see handleCreateTask below). monthly approximated as 30 days.
+function recurrenceIntervalSeconds(rtype, ri) {
+    const safe = Math.max(1, ri || 1);
+    switch (rtype) {
+        case "minutely": return 60 * safe;
+        case "hourly": return 3600 * safe;
+        case "daily": return 86400 * safe;
+        case "weekly": return 604800 * safe;
+        case "monthly": return 2592000 * safe;
+        default: return 60;
+    }
+}
 function validateRecurrence(params) {
     const rtRaw = params.recurrence_type ?? "none";
     const rt = rtRaw.toLowerCase();
@@ -844,6 +860,32 @@ async function handleCreateTask(supabase, userId, resolveAgent, params, fallback
                 if (nextRunAtEpoch <= nowEpoch) {
                     nextRunAtEpoch = nowEpoch + 60 + Math.floor(Math.random() * 300);
                 }
+                // Fix #3 (2026-05-17): bulk-recurring stagger safety net. Fix #2
+                // only jitters past-time bumps; an LLM that intentionally seeds
+                // 6+ recurring tasks with a shared FUTURE T0 anchor still bursts
+                // every tick. Detect the burst by counting recent recurring
+                // scheduler_events for this user (last 60s); once >3 exist, push
+                // the new task's first fire by (recent × per-slot) seconds where
+                // per-slot = min(recurrence_interval_secs, 1800). For 6 minutely
+                // creates this spreads first-fires across ~5 min instead of one
+                // pg_cron tick. Cap per-slot at 30min so long-interval cadences
+                // (hourly/daily) don't push first fires hours out.
+                const rTypeStr = params.recurrence_type || "none";
+                const rIntervalNum = params.recurrence_interval || 1;
+                if (rTypeStr !== "none" && rIntervalNum > 0) {
+                    const sinceISO = new Date(Date.now() - 60_000).toISOString();
+                    const { count: recentCount } = await supabase.from("scheduler_events")
+                        .select("id", { count: "exact", head: true })
+                        .eq("user_id", userId)
+                        .neq("recurrence_type", "none")
+                        .gte("created_at", sinceISO);
+                    const recent = recentCount ?? 0;
+                    if (recent >= 3) {
+                        const ivSecs = recurrenceIntervalSeconds(rTypeStr, rIntervalNum);
+                        const perSlotSecs = Math.min(ivSecs, 1800);
+                        nextRunAtEpoch += recent * perSlotSecs;
+                    }
+                }
                 await supabase.from("scheduler_events").insert({
                     id: crypto.randomUUID(),
                     user_id: userId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.56.5",
+  "version": "4.56.6",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 18 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, agent brain, talent management, corporate frameworks, agent office canvas, and PM gate approvals",
   "keywords": [

package/src/tools.ts

@@ -292,6 +292,7 @@ function registerTaskOps(
       `  • "every N weeks"   → recurrence_type:"weekly"   + recurrence_interval:N\n` +
       `  • "every N months"  → recurrence_type:"monthly"  + recurrence_interval:N\n` +
       `🛑 NEVER use daily+1 (or hourly+24, etc.) when the user said a minute-level cadence — the task will fire ONCE per 24h instead of every N minutes. This was a real prod bug (v1 smoke 2026-05-17).\n` +
+      `🚦 BURST GUARD (Fix #3, 2026-05-17): when you create >3 recurring tasks within 60s for the same user, the server auto-staggers each new task's first fire by (count × min(recurrence_interval_secs, 1800)) so 6+ tasks with a shared T0 anchor do NOT all burst on the same pg_cron tick. Pass distinct start_date values per task if you need precise first-fire times.\n` +
       `\n` +
       `Approvals: Use add_approval to request sign-off from humans or agents. Approvals are separate from workflow gate nodes.\n` +
       `Status: PENDING, IN_PROGRESS, DONE, FAILED | Priority: 0=LOW, 1=MEDIUM, 2=HIGH, 3=CRITICAL`,
@@ -660,6 +661,22 @@ function humanizeCadence(type: string, interval: number): string {
   return interval === 1 ? `every ${unit}` : `every ${interval} ${unit}s`;
 }
 
+// Fix #3 (2026-05-17): bulk-create stagger helper. Maps recurrence_type +
+// interval to cadence in seconds; used to compute the per-slot offset
+// applied when a user bulk-creates >3 recurring scheduler_events within a
+// 60s window (see handleCreateTask below). monthly approximated as 30 days.
+function recurrenceIntervalSeconds(rtype: string, ri: number): number {
+  const safe = Math.max(1, ri || 1);
+  switch (rtype) {
+    case "minutely": return 60 * safe;
+    case "hourly":   return 3600 * safe;
+    case "daily":    return 86400 * safe;
+    case "weekly":   return 604800 * safe;
+    case "monthly":  return 2592000 * safe;
+    default:         return 60;
+  }
+}
+
 function validateRecurrence(
   params: Record<string, unknown>,
 ): { ok: true } | { ok: false; reason: string } {
@@ -941,6 +958,33 @@ async function handleCreateTask(
           nextRunAtEpoch = nowEpoch + 60 + Math.floor(Math.random() * 300);
         }
 
+        // Fix #3 (2026-05-17): bulk-recurring stagger safety net. Fix #2
+        // only jitters past-time bumps; an LLM that intentionally seeds
+        // 6+ recurring tasks with a shared FUTURE T0 anchor still bursts
+        // every tick. Detect the burst by counting recent recurring
+        // scheduler_events for this user (last 60s); once >3 exist, push
+        // the new task's first fire by (recent × per-slot) seconds where
+        // per-slot = min(recurrence_interval_secs, 1800). For 6 minutely
+        // creates this spreads first-fires across ~5 min instead of one
+        // pg_cron tick. Cap per-slot at 30min so long-interval cadences
+        // (hourly/daily) don't push first fires hours out.
+        const rTypeStr = (params.recurrence_type as string) || "none";
+        const rIntervalNum = (params.recurrence_interval as number) || 1;
+        if (rTypeStr !== "none" && rIntervalNum > 0) {
+          const sinceISO = new Date(Date.now() - 60_000).toISOString();
+          const { count: recentCount } = await supabase.from("scheduler_events")
+            .select("id", { count: "exact", head: true })
+            .eq("user_id", userId)
+            .neq("recurrence_type", "none")
+            .gte("created_at", sinceISO);
+          const recent = recentCount ?? 0;
+          if (recent >= 3) {
+            const ivSecs = recurrenceIntervalSeconds(rTypeStr, rIntervalNum);
+            const perSlotSecs = Math.min(ivSecs, 1800);
+            nextRunAtEpoch += recent * perSlotSecs;
+          }
+        }
+
         await supabase.from("scheduler_events").insert({
           id: crypto.randomUUID(),
           user_id: userId,