ofiere-openclaw-plugin 4.56.5 → 4.56.7

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();
@@ -833,7 +849,8 @@ async function handleCreateTask(supabase, userId, resolveAgent, params, fallback
         const effectiveAgentId = insertData.agent_id || assignee;
         if (startDate && effectiveAgentId && normalized) {
             try {
-                let { nextRunAtEpoch } = normalized;
+                const originalEpoch = normalized.nextRunAtEpoch;
+                let nextRunAtEpoch = originalEpoch;
                 const nowEpoch = Math.floor(Date.now() / 1000);
                 // Safety net: if computed time is in the past, schedule for now + 60s
                 // Fix #2 (2026-05-17): jitter past-time bump 0..5min so bulk creates
@@ -844,6 +861,47 @@ 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;
+                    }
+                }
+                // Fix #3 cosmetic parity (2026-05-17): when either Fix #2 jitter or
+                // Fix #3 stagger mutated nextRunAtEpoch, recompute the local-clock
+                // display fields so the dashboard UI doesn't show the ORIGINAL T0 for
+                // an event that actually fires minutes later. Dispatch uses
+                // next_run_at, but users read scheduled_date+scheduled_time.
+                let scheduledDateLocalFinal = normalized.scheduledDateLocal;
+                let scheduledTimeLocalFinal = normalized.scheduledTimeLocal;
+                if (nextRunAtEpoch !== originalEpoch) {
+                    const offsetMin = Math.round(TZ_OFFSET_HOURS * 60);
+                    const localMs = nextRunAtEpoch * 1000 + offsetMin * 60 * 1000;
+                    const localD = new Date(localMs);
+                    const padN = (n) => String(n).padStart(2, "0");
+                    scheduledDateLocalFinal = `${localD.getUTCFullYear()}-${padN(localD.getUTCMonth() + 1)}-${padN(localD.getUTCDate())}`;
+                    scheduledTimeLocalFinal = `${padN(localD.getUTCHours())}:${padN(localD.getUTCMinutes())}`;
+                }
                 await supabase.from("scheduler_events").insert({
                     id: crypto.randomUUID(),
                     user_id: userId,
@@ -852,8 +910,8 @@ async function handleCreateTask(supabase, userId, resolveAgent, params, fallback
                     subagent_id: subagentId,
                     title: params.title,
                     description: params.description || params.instructions || null,
-                    scheduled_date: normalized.scheduledDateLocal,
-                    scheduled_time: normalized.scheduledTimeLocal,
+                    scheduled_date: scheduledDateLocalFinal,
+                    scheduled_time: scheduledTimeLocalFinal,
                     duration_minutes: 30,
                     recurrence_type: params.recurrence_type || "none",
                     recurrence_interval: params.recurrence_interval || 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.56.5",
+  "version": "4.56.7",
   "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 } {
@@ -929,7 +946,8 @@ async function handleCreateTask(
     const effectiveAgentId = (insertData.agent_id as string) || assignee;
     if (startDate && effectiveAgentId && normalized) {
       try {
-        let { nextRunAtEpoch } = normalized;
+        const originalEpoch = normalized.nextRunAtEpoch;
+        let nextRunAtEpoch = originalEpoch;
         const nowEpoch = Math.floor(Date.now() / 1000);
         // Safety net: if computed time is in the past, schedule for now + 60s
         // Fix #2 (2026-05-17): jitter past-time bump 0..5min so bulk creates
@@ -941,6 +959,49 @@ 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;
+          }
+        }
+
+        // Fix #3 cosmetic parity (2026-05-17): when either Fix #2 jitter or
+        // Fix #3 stagger mutated nextRunAtEpoch, recompute the local-clock
+        // display fields so the dashboard UI doesn't show the ORIGINAL T0 for
+        // an event that actually fires minutes later. Dispatch uses
+        // next_run_at, but users read scheduled_date+scheduled_time.
+        let scheduledDateLocalFinal = normalized.scheduledDateLocal;
+        let scheduledTimeLocalFinal = normalized.scheduledTimeLocal;
+        if (nextRunAtEpoch !== originalEpoch) {
+          const offsetMin = Math.round(TZ_OFFSET_HOURS * 60);
+          const localMs = nextRunAtEpoch * 1000 + offsetMin * 60 * 1000;
+          const localD = new Date(localMs);
+          const padN = (n: number) => String(n).padStart(2, "0");
+          scheduledDateLocalFinal = `${localD.getUTCFullYear()}-${padN(localD.getUTCMonth() + 1)}-${padN(localD.getUTCDate())}`;
+          scheduledTimeLocalFinal = `${padN(localD.getUTCHours())}:${padN(localD.getUTCMinutes())}`;
+        }
+
         await supabase.from("scheduler_events").insert({
           id: crypto.randomUUID(),
           user_id: userId,
@@ -949,8 +1010,8 @@ async function handleCreateTask(
           subagent_id: subagentId,
           title: params.title,
           description: (params.description as string) || (params.instructions as string) || null,
-          scheduled_date: normalized.scheduledDateLocal,
-          scheduled_time: normalized.scheduledTimeLocal,
+          scheduled_date: scheduledDateLocalFinal,
+          scheduled_time: scheduledTimeLocalFinal,
           duration_minutes: 30,
           recurrence_type: (params.recurrence_type as string) || "none",
           recurrence_interval: (params.recurrence_interval as number) || 1,