ofiere-openclaw-plugin 4.56.4 → 4.56.6

package/dist/src/tools.js

@@ -244,7 +244,18 @@ function registerTaskOps(api, supabase, userId, resolveAgent, timezone) {
             `For simple tasks, just provide title and optionally description.\n` +
             `agent_id: Pass your name to self-assign, another agent's name, or 'none'.\n` +
             `subagent_id: When delegating to one of your own staff, pass the staff UUID here AND set agent_id to yourself (or the chief). The staff's chief_agent_id MUST match agent_id or the call rejects with subagent_chief_mismatch. Use OFIERE_AGENT_OPS list_subagents to discover available staff under a chief.\n` +
-            `For recurring tasks: set start_date + recurrence_type + recurrence_interval. Example: every 2 minutes = recurrence_type: "minutely", recurrence_interval: 2.\n` +
+            `\n` +
+            `For recurring tasks: set start_date + recurrence_type + recurrence_interval.\n` +
+            `⚠️ CADENCE MAPPING — match the user's spoken phrase EXACTLY (server-side cadence-intent guard rejects mismatches):\n` +
+            `  • "every N seconds" → recurrence_type:"minutely" + recurrence_interval:max(1, ceil(N/60))  ← cron resolution = 1 minute\n` +
+            `  • "every N minutes" → recurrence_type:"minutely" + recurrence_interval:N   ← e.g. every 35 min → minutely+35\n` +
+            `  • "every N hours"   → recurrence_type:"hourly"   + recurrence_interval:N\n` +
+            `  • "every N days"    → recurrence_type:"daily"    + recurrence_interval:N   ← daily+1 = 24h gap!\n` +
+            `  • "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`,
         parameters: {
@@ -561,10 +572,119 @@ function normalizeStartDate(startDate, explicitScheduledTime, tzOffsetHours) {
         scheduledDateLocal: `${year}-${pad(month)}-${pad(day)}`,
     };
 }
+// ── Fix #10 (2026-05-17): Cadence-intent guard ──────────────────────────────
+// v1 smoke incident: LLM picked recurrence_type='daily' + recurrence_interval=1
+// for a task whose title said "every 35 minutes" — so it fired ONCE per 24h
+// instead of every 35 min. Silent test failure. This guard inspects the task
+// text for an explicit "every N <unit>" phrase and rejects the create when the
+// chosen recurrence_type/interval doesn't match. Combined with the tightened
+// OFIERE_TASK_OPS description (cadence-mapping table), prevents the drift at
+// both the LLM-prompt layer and the server-runtime layer.
+const RECURRENCE_TYPES = ["none", "minutely", "hourly", "daily", "weekly", "monthly"];
+function humanizeCadence(type, interval) {
+    if (type === "none")
+        return "one-shot";
+    const unitMap = {
+        minutely: "minute",
+        hourly: "hour",
+        daily: "day",
+        weekly: "week",
+        monthly: "month",
+    };
+    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();
+    const riRaw = params.recurrence_interval;
+    const ri = typeof riRaw === "number" ? riRaw : (riRaw === undefined ? 1 : Number(riRaw));
+    if (!RECURRENCE_TYPES.includes(rt)) {
+        return {
+            ok: false,
+            reason: `Invalid recurrence_type "${rtRaw}". Must be one of: ${RECURRENCE_TYPES.join(", ")}.`,
+        };
+    }
+    if (rt === "none")
+        return { ok: true };
+    if (!Number.isFinite(ri) || !Number.isInteger(ri) || ri < 1 || ri > 9999) {
+        return {
+            ok: false,
+            reason: `Invalid recurrence_interval ${riRaw}. Must be a positive integer between 1 and 9999.`,
+        };
+    }
+    // Cadence-intent guard: scan title + description for an "every N <unit>"
+    // phrase. If present, the chosen recurrence_type+interval MUST match.
+    const text = `${params.title || ""} ${params.description || ""}`.toLowerCase();
+    const cadenceMatch = text.match(/every\s+(\d+)\s*(seconds?|secs?|minutes?|mins?|hours?|hrs?|days?|weeks?|months?)\b/);
+    if (!cadenceMatch)
+        return { ok: true };
+    const n = parseInt(cadenceMatch[1], 10);
+    const unitRaw = cadenceMatch[2];
+    let expectedType;
+    let expectedInterval;
+    if (/^sec/.test(unitRaw)) {
+        expectedType = "minutely";
+        expectedInterval = Math.max(1, Math.ceil(n / 60));
+    }
+    else if (/^min/.test(unitRaw)) {
+        expectedType = "minutely";
+        expectedInterval = n;
+    }
+    else if (/^(hour|hr)/.test(unitRaw)) {
+        expectedType = "hourly";
+        expectedInterval = n;
+    }
+    else if (/^day/.test(unitRaw)) {
+        expectedType = "daily";
+        expectedInterval = n;
+    }
+    else if (/^week/.test(unitRaw)) {
+        expectedType = "weekly";
+        expectedInterval = n;
+    }
+    else if (/^month/.test(unitRaw)) {
+        expectedType = "monthly";
+        expectedInterval = n;
+    }
+    else {
+        return { ok: true };
+    }
+    if (rt !== expectedType || ri !== expectedInterval) {
+        return {
+            ok: false,
+            reason: `Recurrence mismatch: task text says "every ${n} ${unitRaw}" but you passed ` +
+                `recurrence_type="${rt}", recurrence_interval=${ri} (= ${humanizeCadence(rt, ri)}). ` +
+                `Correct combo: recurrence_type="${expectedType}", recurrence_interval=${expectedInterval} ` +
+                `(= ${humanizeCadence(expectedType, expectedInterval)}). ` +
+                `Re-call with the matching values, OR remove the "every N ${unitRaw}" phrase from the title/description if you intended a different cadence.`,
+        };
+    }
+    return { ok: true };
+}
 async function handleCreateTask(supabase, userId, resolveAgent, params, fallbackTimezone = "Asia/Jakarta") {
     try {
         if (!params.title)
             return err("Missing required field: title");
+        // Fix #10 (2026-05-17): cadence-intent guard — see helper comment above.
+        const recurCheck = validateRecurrence(params);
+        if (!recurCheck.ok)
+            return err(recurCheck.reason);
         const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const now = new Date().toISOString();
         // BUG 5 fix: resolve user's IANA timezone from their profile row. Plugin
@@ -740,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,
@@ -774,9 +920,16 @@ async function handleCreateTask(supabase, userId, resolveAgent, params, fallback
             extras.push(`${cf.constraints.length} constraints`);
         if (cf.system_prompt)
             extras.push("custom system prompt");
-        // BUG 6 fix: surface recurrence fields in create response
+        // BUG 6 fix: surface recurrence fields in create response.
+        // Fix #10 (2026-05-17): also surface effective_cadence so the LLM sees the
+        // human-readable interpretation (e.g. "every 35 minutes") of the values it
+        // just passed — defense-in-depth alongside validateRecurrence().
         const recurrenceInfo = (params.recurrence_type && params.recurrence_type !== "none")
-            ? { recurrence_type: params.recurrence_type, recurrence_interval: params.recurrence_interval || 1 }
+            ? {
+                recurrence_type: params.recurrence_type,
+                recurrence_interval: params.recurrence_interval || 1,
+                effective_cadence: humanizeCadence(params.recurrence_type, params.recurrence_interval || 1),
+            }
             : undefined;
         // BUG 7 fix: only claim scheduling when bridge actually fired
         const didSchedule = !!(startDate && effectiveAgentId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.56.4",
+  "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

@@ -282,7 +282,18 @@ function registerTaskOps(
       `For simple tasks, just provide title and optionally description.\n` +
       `agent_id: Pass your name to self-assign, another agent's name, or 'none'.\n` +
       `subagent_id: When delegating to one of your own staff, pass the staff UUID here AND set agent_id to yourself (or the chief). The staff's chief_agent_id MUST match agent_id or the call rejects with subagent_chief_mismatch. Use OFIERE_AGENT_OPS list_subagents to discover available staff under a chief.\n` +
-      `For recurring tasks: set start_date + recurrence_type + recurrence_interval. Example: every 2 minutes = recurrence_type: "minutely", recurrence_interval: 2.\n` +
+      `\n` +
+      `For recurring tasks: set start_date + recurrence_type + recurrence_interval.\n` +
+      `⚠️ CADENCE MAPPING — match the user's spoken phrase EXACTLY (server-side cadence-intent guard rejects mismatches):\n` +
+      `  • "every N seconds" → recurrence_type:"minutely" + recurrence_interval:max(1, ceil(N/60))  ← cron resolution = 1 minute\n` +
+      `  • "every N minutes" → recurrence_type:"minutely" + recurrence_interval:N   ← e.g. every 35 min → minutely+35\n` +
+      `  • "every N hours"   → recurrence_type:"hourly"   + recurrence_interval:N\n` +
+      `  • "every N days"    → recurrence_type:"daily"    + recurrence_interval:N   ← daily+1 = 24h gap!\n` +
+      `  • "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`,
     parameters: {
@@ -625,6 +636,122 @@ function normalizeStartDate(
   };
 }
 
+// ── Fix #10 (2026-05-17): Cadence-intent guard ──────────────────────────────
+// v1 smoke incident: LLM picked recurrence_type='daily' + recurrence_interval=1
+// for a task whose title said "every 35 minutes" — so it fired ONCE per 24h
+// instead of every 35 min. Silent test failure. This guard inspects the task
+// text for an explicit "every N <unit>" phrase and rejects the create when the
+// chosen recurrence_type/interval doesn't match. Combined with the tightened
+// OFIERE_TASK_OPS description (cadence-mapping table), prevents the drift at
+// both the LLM-prompt layer and the server-runtime layer.
+
+const RECURRENCE_TYPES = ["none", "minutely", "hourly", "daily", "weekly", "monthly"] as const;
+type RecurrenceType = (typeof RECURRENCE_TYPES)[number];
+
+function humanizeCadence(type: string, interval: number): string {
+  if (type === "none") return "one-shot";
+  const unitMap: Record<string, string> = {
+    minutely: "minute",
+    hourly: "hour",
+    daily: "day",
+    weekly: "week",
+    monthly: "month",
+  };
+  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: 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 } {
+  const rtRaw = (params.recurrence_type as string | undefined) ?? "none";
+  const rt = rtRaw.toLowerCase() as RecurrenceType;
+  const riRaw = params.recurrence_interval;
+  const ri = typeof riRaw === "number" ? riRaw : (riRaw === undefined ? 1 : Number(riRaw));
+
+  if (!RECURRENCE_TYPES.includes(rt)) {
+    return {
+      ok: false,
+      reason:
+        `Invalid recurrence_type "${rtRaw}". Must be one of: ${RECURRENCE_TYPES.join(", ")}.`,
+    };
+  }
+
+  if (rt === "none") return { ok: true };
+
+  if (!Number.isFinite(ri) || !Number.isInteger(ri) || ri < 1 || ri > 9999) {
+    return {
+      ok: false,
+      reason:
+        `Invalid recurrence_interval ${riRaw}. Must be a positive integer between 1 and 9999.`,
+    };
+  }
+
+  // Cadence-intent guard: scan title + description for an "every N <unit>"
+  // phrase. If present, the chosen recurrence_type+interval MUST match.
+  const text = `${(params.title as string) || ""} ${(params.description as string) || ""}`.toLowerCase();
+  const cadenceMatch = text.match(
+    /every\s+(\d+)\s*(seconds?|secs?|minutes?|mins?|hours?|hrs?|days?|weeks?|months?)\b/,
+  );
+  if (!cadenceMatch) return { ok: true };
+
+  const n = parseInt(cadenceMatch[1], 10);
+  const unitRaw = cadenceMatch[2];
+  let expectedType: RecurrenceType;
+  let expectedInterval: number;
+  if (/^sec/.test(unitRaw)) {
+    expectedType = "minutely";
+    expectedInterval = Math.max(1, Math.ceil(n / 60));
+  } else if (/^min/.test(unitRaw)) {
+    expectedType = "minutely";
+    expectedInterval = n;
+  } else if (/^(hour|hr)/.test(unitRaw)) {
+    expectedType = "hourly";
+    expectedInterval = n;
+  } else if (/^day/.test(unitRaw)) {
+    expectedType = "daily";
+    expectedInterval = n;
+  } else if (/^week/.test(unitRaw)) {
+    expectedType = "weekly";
+    expectedInterval = n;
+  } else if (/^month/.test(unitRaw)) {
+    expectedType = "monthly";
+    expectedInterval = n;
+  } else {
+    return { ok: true };
+  }
+
+  if (rt !== expectedType || ri !== expectedInterval) {
+    return {
+      ok: false,
+      reason:
+        `Recurrence mismatch: task text says "every ${n} ${unitRaw}" but you passed ` +
+        `recurrence_type="${rt}", recurrence_interval=${ri} (= ${humanizeCadence(rt, ri)}). ` +
+        `Correct combo: recurrence_type="${expectedType}", recurrence_interval=${expectedInterval} ` +
+        `(= ${humanizeCadence(expectedType, expectedInterval)}). ` +
+        `Re-call with the matching values, OR remove the "every N ${unitRaw}" phrase from the title/description if you intended a different cadence.`,
+    };
+  }
+
+  return { ok: true };
+}
+
 async function handleCreateTask(
   supabase: SupabaseClient,
   userId: string,
@@ -635,6 +762,10 @@ async function handleCreateTask(
   try {
     if (!params.title) return err("Missing required field: title");
 
+    // Fix #10 (2026-05-17): cadence-intent guard — see helper comment above.
+    const recurCheck = validateRecurrence(params);
+    if (!recurCheck.ok) return err(recurCheck.reason);
+
     const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const now = new Date().toISOString();
 
@@ -827,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,
@@ -858,9 +1016,19 @@ async function handleCreateTask(
     if (cf.constraints) extras.push(`${(cf.constraints as any[]).length} constraints`);
     if (cf.system_prompt) extras.push("custom system prompt");
 
-    // BUG 6 fix: surface recurrence fields in create response
+    // BUG 6 fix: surface recurrence fields in create response.
+    // Fix #10 (2026-05-17): also surface effective_cadence so the LLM sees the
+    // human-readable interpretation (e.g. "every 35 minutes") of the values it
+    // just passed — defense-in-depth alongside validateRecurrence().
     const recurrenceInfo = (params.recurrence_type && params.recurrence_type !== "none")
-      ? { recurrence_type: params.recurrence_type, recurrence_interval: (params.recurrence_interval as number) || 1 }
+      ? {
+          recurrence_type: params.recurrence_type,
+          recurrence_interval: (params.recurrence_interval as number) || 1,
+          effective_cadence: humanizeCadence(
+            params.recurrence_type as string,
+            (params.recurrence_interval as number) || 1,
+          ),
+        }
       : undefined;
 
     // BUG 7 fix: only claim scheduling when bridge actually fired