ofiere-openclaw-plugin 4.56.4 → 4.56.5

package/dist/src/tools.js

@@ -244,7 +244,17 @@ 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` +
+            `\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 +571,104 @@ 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`;
+}
+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
@@ -774,9 +878,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.5",
   "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,17 @@ 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` +
+      `\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 +635,106 @@ 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`;
+}
+
+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 +745,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();
 
@@ -858,9 +972,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