ofiere-openclaw-plugin 4.33.0 → 4.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.33.0",
+  "version": "4.35.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 14 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, SOP management, and agent brain (memory + self-improvement)",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/config.ts

@@ -7,6 +7,7 @@ export const OfiereConfigSchema = z.object({
   serviceRoleKey: z.string().default(""),
   userId: z.string().default(""),
   agentId: z.string().default(""),
+  timezone: z.string().default("Asia/Jakarta"),
 });
 
 // Cache the first successful config so per-agent re-registrations don't lose it
@@ -52,12 +53,20 @@ export function parseOfiereConfig(value: unknown): OfiereConfig {
     _cachedConfig?.agentId ||
     "";
 
+  const timezone =
+    (typeof configObj?.timezone === "string" && configObj.timezone.trim()) ||
+    (typeof raw.timezone === "string" && raw.timezone.trim()) ||
+    process.env.OFIERE_TIMEZONE ||
+    _cachedConfig?.timezone ||
+    "Asia/Jakarta";
+
   const parsed = OfiereConfigSchema.parse({
     ...raw,
     supabaseUrl,
     serviceRoleKey,
     userId,
     agentId,
+    timezone,
   });
 
   // Cache if this parse yielded a complete config

package/src/prompt.ts

@@ -26,6 +26,7 @@ const TOOL_SUMMARIES: Record<string, string> = {
   OFIERE_PLAN_OPS: "Visual execution plan builder (DAG drafts → real tasks)",
   OFIERE_SOP_OPS: "Standard Operating Procedures for department chiefs",
   OFIERE_BRAIN_OPS: "Agent memory, knowledge graph, self-improvement (TMT/MAGMA)",
+  OFIERE_TALENT_OPS: "Talents: list, get, activate, deactivate cognitive skill presets",
 };
 
 // ─── Tier B: Full Tool Documentation ────────────────────────────────────────
@@ -113,6 +114,15 @@ Actions: "list_templates", "create", "list", "get", "update", "delete", "list_su
 Memory Tiers: L1_focus (24h), L2_episode (days), L3_pattern (weeks), L4_rule (permanent), L5_persona (permanent)
 Actions: save_memory, recall, delete_memory, promote_memory, log_learning, list_learnings, resolve_learning, save_entity, link_entities, query_graph, start_trajectory, end_trajectory, get_brain_status
 - This is your SUBCONSCIOUS — use instinctively, not deliberately`,
+
+  OFIERE_TALENT_OPS: `Manage cognitive skill presets (Talents).
+Actions: "list", "get", "activate", "deactivate"
+- list: List all talents. Optional: category, scope, status
+- get: Get full talent details. Required: talent_id OR name
+- activate: Enable a talent (status → active). Required: talent_id
+- deactivate: Disable a talent (status → inactive). Required: talent_id
+- Active talents inject their execution_protocol and guardrails into your system prompt automatically
+- Talents chain other tools: SPHINX chains KNOWLEDGE_OPS+BRAIN_OPS, PRISM chains BRAIN_OPS trajectories, ATLAS chains PLAN_OPS+TASK_OPS+SOP_OPS`,
 };
 
 export function getSystemPrompt(state: {
@@ -146,6 +156,11 @@ Full parameter docs are in each tool's description — call the tool to see deta
 
 ${toolIndex}
 
+## ⛔ PLANNING GATE (NON-NEGOTIABLE)
+- Before creating ANY task with 3+ total execution steps, goals, or constraints, you MUST ask the user: "Would you like me to plan this first, or create the task directly?"
+- If the user chooses to plan, use OFIERE_PLAN_OPS to create a visual plan first, then execute it.
+- NEVER skip this step. The server will block creation of complex tasks — use action: "create_force" only if the user explicitly confirms bypass.
+
 ## Rules
 - ALWAYS pass agent_id with your own name when creating tasks (e.g. agent_id: "ivy").
 - ${assignRule}
@@ -159,7 +174,6 @@ ${toolIndex}
 - CONSTELLATION: ALWAYS read_blueprint before creating/editing agents. ALWAYS confirm before delete.
 - WORKFLOWS: ALWAYS "get" before modifying. Use "insert_node_between" for mid-flow additions.
 - CHANNEL REPORTS: ALWAYS include agent_id (YOUR name) in send_report. Use get_task_detail for drill-down.
-- **PLANNING GATE (MANDATORY):** Before creating ANY task with 3+ execution steps, goals, constraints, OR a due_date, you MUST ask the user: "Would you like me to plan this first, or create the task directly?" If the user chooses to plan, use OFIERE_PLAN_OPS to create a visual plan first, then execute it to generate the real tasks. Do NOT skip this step.
 - File refs @[name](file:ID): Use OFIERE_FILE_OPS read_text_file to retrieve — don't ask user.
 - Task approvals (OFIERE_TASK_OPS) ≠ workflow gate approvals (human_approval nodes).
 

package/src/tools.ts

@@ -189,6 +189,7 @@ function registerTaskOps(
   supabase: SupabaseClient,
   userId: string,
   resolveAgent: (id?: string) => Promise<string | null>,
+  timezone: string,
 ): void {
   api.registerTool({
     name: "OFIERE_TASK_OPS",
@@ -217,7 +218,7 @@ function registerTaskOps(
         action: {
           type: "string",
           description: "The operation to perform",
-          enum: ["list", "get", "create", "update", "delete", "add_approval", "list_approvals", "resolve_approval"],
+          enum: ["list", "get", "create", "create_force", "update", "delete", "add_approval", "list_approvals", "resolve_approval"],
         },
         title: { type: "string", description: "Task title (required for create)" },
         description: { type: "string", description: "Task description" },
@@ -314,8 +315,25 @@ function registerTaskOps(
         case "get":
           if (!params.task_id) return err("Missing required field: task_id");
           return handleListTasks(supabase, userId, { ...params, limit: 1 });
-        case "create":
-          return handleCreateTask(supabase, userId, resolveAgent, params);
+        case "create": {
+          // ── PLANNING GATE — server-side enforcement ──
+          // Trigger only on steps/goals/constraints count >= 3
+          const execSteps = Array.isArray(params.execution_plan) ? (params.execution_plan as any[]).length : 0;
+          const goalCount = Array.isArray(params.goals) ? (params.goals as any[]).length : 0;
+          const constraintCount = Array.isArray(params.constraints) ? (params.constraints as any[]).length : 0;
+          const complexityCount = execSteps + goalCount + constraintCount;
+          if (complexityCount >= 3) {
+            return ok({
+              blocked: true,
+              message: `⚠️ PLANNING GATE: This task has ${complexityCount} execution steps/goals/constraints (${execSteps} steps, ${goalCount} goals, ${constraintCount} constraints). Planning Mode is mandatory for complex tasks. Ask the user: "Would you like me to plan this first using OFIERE_PLAN_OPS, or force-create with action: 'create_force'?"`,
+              hint: "To bypass: re-call with action 'create_force'. To plan first: use OFIERE_PLAN_OPS.",
+            });
+          }
+          return handleCreateTask(supabase, userId, resolveAgent, params, timezone);
+        }
+        case "create_force":
+          // Bypasses planning gate — agent explicitly chose to skip planning
+          return handleCreateTask(supabase, userId, resolveAgent, params, timezone);
         case "update":
           return handleUpdateTask(supabase, userId, params);
         case "delete":
@@ -328,7 +346,7 @@ function registerTaskOps(
           return handleResolveApproval(supabase, userId, params);
         default:
           return err(
-            `Unknown action "${action}". Valid actions: list, get, create, update, delete, add_approval, list_approvals, resolve_approval`,
+            `Unknown action "${action}". Valid actions: list, get, create, create_force, update, delete, add_approval, list_approvals, resolve_approval`,
           );
       }
     },
@@ -397,6 +415,7 @@ async function handleCreateTask(
   userId: string,
   resolveAgent: (id?: string) => Promise<string | null>,
   params: Record<string, unknown>,
+  timezone: string = "Asia/Jakarta",
 ): Promise<ToolResult> {
   try {
     if (!params.title) return err("Missing required field: title");
@@ -547,7 +566,20 @@ async function handleCreateTask(
     // We convert to UTC epoch for next_run_at so the edge function fires correctly.
     const startDate = params.start_date as string | undefined;
     const effectiveAgentId = (insertData.agent_id as string) || assignee;
-    const WIB_OFFSET_HOURS = 7; // Asia/Jakarta = UTC+7
+
+    // Resolve timezone offset from IANA timezone string (configurable per user)
+    const getTimezoneOffsetHours = (tz: string): number => {
+      try {
+        const now = new Date();
+        const utcStr = now.toLocaleString('en-US', { timeZone: 'UTC' });
+        const tzStr = now.toLocaleString('en-US', { timeZone: tz });
+        const diffMs = new Date(tzStr).getTime() - new Date(utcStr).getTime();
+        return Math.round(diffMs / 3600000);
+      } catch {
+        return 7; // Fallback to WIB (UTC+7)
+      }
+    };
+    const TZ_OFFSET_HOURS = getTimezoneOffsetHours(timezone);
     if (startDate && effectiveAgentId) {
       try {
         // Parse start_date robustly — it can be:
@@ -567,17 +599,19 @@ async function handleCreateTask(
           const hasTimeInfo = /[T ]\d{2}:\d{2}/.test(startDate);
 
           if (explicitScheduledTime) {
-            // Agent explicitly passed a scheduled_time — treat as WIB local time
+            // Agent explicitly passed a scheduled_time — treat as user’s local time
             const dateStr = parsedDate.toISOString().split("T")[0]; // YYYY-MM-DD
             const [localH, localM] = explicitScheduledTime.split(":").map(Number);
-            const utcH = localH - WIB_OFFSET_HOURS;
+            const utcH = localH - TZ_OFFSET_HOURS;
             const dt = new Date(`${dateStr}T00:00:00Z`);
             dt.setUTCHours(utcH, localM, 0, 0);
             nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
             scheduledTimeFinal = explicitScheduledTime; // Store as user's local time
             scheduledDateFinal = dateStr;
+            // Normalize start_date to ISO UTC for consistent downstream parsing
+            insertData.start_date = dt.toISOString();
           } else if (hasTimeInfo) {
-            // start_date already contains time — assume it's in the user's local timezone (WIB)
+            // start_date already contains time — assume it’s in the user’s local timezone
             // Extract the local hour:minute from the string, NOT from UTC parsing
             const timeMatch = startDate.match(/(\d{2}):(\d{2})/);
             if (timeMatch) {
@@ -585,10 +619,12 @@ async function handleCreateTask(
               const localM = parseInt(timeMatch[2], 10);
               const dateStr = parsedDate.toISOString().split("T")[0];
               const dt = new Date(`${dateStr}T00:00:00Z`);
-              dt.setUTCHours(localH - WIB_OFFSET_HOURS, localM, 0, 0);
+              dt.setUTCHours(localH - TZ_OFFSET_HOURS, localM, 0, 0);
               nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
               scheduledTimeFinal = `${String(localH).padStart(2, "0")}:${String(localM).padStart(2, "0")}`;
               scheduledDateFinal = dateStr;
+              // Normalize start_date to ISO UTC
+              insertData.start_date = dt.toISOString();
             } else {
               // Can't extract time — fall back to UTC parsing
               nextRunAtEpoch = Math.floor(parsedDate.getTime() / 1000);
@@ -596,13 +632,15 @@ async function handleCreateTask(
               scheduledDateFinal = parsedDate.toISOString().split("T")[0];
             }
           } else {
-            // Date only, no time — default to 09:00 WIB (= 02:00 UTC)
+            // Date only, no time — default to 09:00 user local time
             const dateStr = parsedDate.toISOString().split("T")[0];
             const dt = new Date(`${dateStr}T00:00:00Z`);
-            dt.setUTCHours(9 - WIB_OFFSET_HOURS, 0, 0, 0); // 09:00 WIB = 02:00 UTC
+            dt.setUTCHours(9 - TZ_OFFSET_HOURS, 0, 0, 0); // 09:00 local = UTC - offset
             nextRunAtEpoch = Math.floor(dt.getTime() / 1000);
-            scheduledTimeFinal = "09:00"; // Stored as WIB local time
+            scheduledTimeFinal = "09:00"; // Stored as user's local time
             scheduledDateFinal = dateStr;
+            // Normalize start_date to ISO UTC
+            insertData.start_date = dt.toISOString();
           }
         } else {
           // Unparseable date — fallback to now + 60s
@@ -633,7 +671,7 @@ async function handleCreateTask(
           next_run_at: nextRunAtEpoch,
           run_count: 0,
           priority: params.priority !== undefined ? params.priority : 1,
-          timezone: "Asia/Jakarta",
+          timezone: timezone,
         });
       } catch (schedErr) {
         // Non-fatal: task was created, just the scheduler event failed
@@ -5594,6 +5632,191 @@ function registerBrainOps(
   }));
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// TALENT OPS — Cognitive Skill Presets (list / get / activate / deactivate)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerTalentOps(
+  api: any, supabase: SupabaseClient, userId: string,
+) {
+  api.registerTool(api.createToolDefinition({
+    name: "OFIERE_TALENT_OPS",
+    label: "Ofiere Talent Operations",
+    description:
+      `Manage cognitive skill presets (Talents).\n` +
+      `Actions: "list", "get", "activate", "deactivate"\n` +
+      `- list: List all talents. Optional: category, scope, status\n` +
+      `- get: Get full talent details. Required: talent_id OR name\n` +
+      `- activate: Enable a talent (status → active). Required: talent_id\n` +
+      `- deactivate: Disable a talent (status → inactive). Required: talent_id\n` +
+      `- Active talents inject their execution_protocol and guardrails into your system prompt automatically\n` +
+      `- Talents chain other tools: SPHINX chains KNOWLEDGE_OPS+BRAIN_OPS, PRISM chains BRAIN_OPS trajectories, ATLAS chains PLAN_OPS+TASK_OPS+SOP_OPS`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: { type: "string", description: "list, get, activate, deactivate" },
+        talent_id: { type: "string", description: "Talent UUID" },
+        name: { type: "string", description: "Talent name (for get by name)" },
+        category: { type: "string", description: "Filter: research, analysis, operations, general" },
+        scope: { type: "string", description: "Filter: global, agent_specific" },
+        status: { type: "string", description: "Filter: active, inactive" },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+      try {
+        switch (action) {
+          case "list": {
+            let q = supabase.from("ofiere_talents")
+              .select("id, name, codename, description, category, icon, scope, status, tags, version")
+              .eq("user_id", userId)
+              .order("created_at", { ascending: false });
+            if (params.category) q = q.eq("category", params.category as string);
+            if (params.scope) q = q.eq("scope", params.scope as string);
+            if (params.status) q = q.eq("status", params.status as string);
+            const { data, error } = await q.limit(50);
+            if (error) return { success: false, result: error.message };
+            return { success: true, result: { talents: data || [], count: data?.length || 0 } };
+          }
+          case "get": {
+            const tid = params.talent_id as string;
+            const tname = params.name as string;
+            if (!tid && !tname) return { success: false, result: "Required: talent_id or name" };
+            let q = supabase.from("ofiere_talents").select("*").eq("user_id", userId);
+            if (tid) q = q.eq("id", tid);
+            else q = q.ilike("name", `%${tname}%`);
+            const { data, error } = await q.limit(1).maybeSingle();
+            if (error) return { success: false, result: error.message };
+            if (!data) return { success: false, result: "Talent not found" };
+            return { success: true, result: data };
+          }
+          case "activate": {
+            const tid = params.talent_id as string;
+            if (!tid) return { success: false, result: "Required: talent_id" };
+            const { error } = await supabase.from("ofiere_talents")
+              .update({ status: "active", updated_at: new Date().toISOString() })
+              .eq("id", tid).eq("user_id", userId);
+            if (error) return { success: false, result: error.message };
+            return { success: true, result: { message: "Talent activated", talent_id: tid } };
+          }
+          case "deactivate": {
+            const tid = params.talent_id as string;
+            if (!tid) return { success: false, result: "Required: talent_id" };
+            const { error } = await supabase.from("ofiere_talents")
+              .update({ status: "inactive", updated_at: new Date().toISOString() })
+              .eq("id", tid).eq("user_id", userId);
+            if (error) return { success: false, result: error.message };
+            return { success: true, result: { message: "Talent deactivated", talent_id: tid } };
+          }
+          default:
+            return { success: false, result: `Unknown action: ${action}. Valid: list, get, activate, deactivate` };
+        }
+      } catch (e) {
+        return { success: false, result: e instanceof Error ? e.message : String(e) };
+      }
+    },
+  }));
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TALENT CONTEXT HOOK — Injects active talent protocols into system prompt
+// ═══════════════════════════════════════════════════════════════════════════════
+// This is the engine that makes talents WORK. Without this hook, talents are
+// just database rows. The hook turns them into cognitive directives injected
+// before every agent turn via appendSystemContext.
+
+const talentCache = new Map<string, { text: string; at: number }>();
+const TALENT_CACHE_TTL = 300_000; // 5 min
+
+function registerTalentContextHook(
+  api: any, supabase: SupabaseClient, userId: string, fallbackAgentId: string,
+) {
+  try {
+    api.on("before_prompt_build", async (_event: any, ctx: any) => {
+      try {
+        const ctxAgentId = ctx?.agentId || "";
+        let resolvedAgentId = fallbackAgentId;
+        if (ctxAgentId && !isSystemName(ctxAgentId)) {
+          try {
+            const resolved = await resolveAgentId(ctxAgentId, userId, supabase);
+            if (resolved) resolvedAgentId = resolved;
+          } catch { /* fallback */ }
+        }
+
+        const cacheKey = `talent:${resolvedAgentId || "global"}`;
+        const cached = talentCache.get(cacheKey);
+        if (cached && (Date.now() - cached.at) < TALENT_CACHE_TTL) {
+          return cached.text ? { appendSystemContext: cached.text } : undefined;
+        }
+
+        // Query active talents: global OR assigned to this agent
+        const { data: talents } = await supabase
+          .from("ofiere_talents")
+          .select("name, codename, execution_protocol, guardrails, trigger_conditions, config")
+          .eq("user_id", userId)
+          .eq("status", "active")
+          .order("created_at", { ascending: true });
+
+        if (!talents || talents.length === 0) {
+          talentCache.set(cacheKey, { text: "", at: Date.now() });
+          return;
+        }
+
+        // Filter: global talents + agent-specific talents assigned to this agent
+        // (assigned_agent_ids check is done client-side since JSONB contains is complex)
+        const sections: string[] = [];
+        for (const t of talents) {
+          const ep = t.execution_protocol || [];
+          const gr = t.guardrails || {};
+          const tc = t.trigger_conditions || {};
+
+          let block = `### 🎯 Talent: ${t.name} (${t.codename || "custom"})`;
+
+          // Triggers
+          const triggers = [
+            ...(tc.keywords || []),
+            ...(tc.explicit_commands || []),
+          ];
+          if (triggers.length > 0) {
+            block += `\nTriggers: ${triggers.join(", ")}`;
+          }
+
+          // Execution Protocol (compact)
+          if (ep.length > 0) {
+            block += "\nExecution Protocol:";
+            for (let i = 0; i < ep.length; i++) {
+              const step = ep[i] as any;
+              block += `\n${i + 1}. **${step.phase}**: ${step.instruction}`;
+              if (step.checkpoint) block += `\n   ✓ Checkpoint: ${step.checkpoint}`;
+            }
+          }
+
+          // Guardrails (compact)
+          const mustNever = gr.must_never || [];
+          const hardConstraints = gr.hard_constraints || [];
+          if (mustNever.length > 0 || hardConstraints.length > 0) {
+            block += "\n⚠️ Guardrails:";
+            for (const mn of mustNever) block += `\n- 🚫 NEVER: ${mn}`;
+            for (const hc of hardConstraints) block += `\n- ⛔ CONSTRAINT: ${hc}`;
+          }
+
+          sections.push(block);
+        }
+
+        const talentContext = `<agent-talents>\n## Your Active Talents (${talents.length})\n\nThese are cognitive skill presets that define HOW you should approach specific types of tasks.\nWhen a user request matches a talent's triggers, follow that talent's execution protocol.\n\n${sections.join("\n\n---\n\n")}\n</agent-talents>`;
+
+        talentCache.set(cacheKey, { text: talentContext, at: Date.now() });
+        return { appendSystemContext: talentContext };
+      } catch (e) {
+        api.logger.debug?.(`[ofiere-talent] before_prompt_build error: ${e instanceof Error ? e.message : e}`);
+      }
+    });
+  } catch {
+    api.logger.debug?.("[ofiere] Could not register talent context hook");
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -5611,7 +5834,7 @@ export function registerTools(
   const resolveAgent = createAgentResolver(api, supabase, userId, fallbackAgentId);
 
   // ── Register each domain meta-tool ──
-  registerTaskOps(api, supabase, userId, resolveAgent);       // 1
+  registerTaskOps(api, supabase, userId, resolveAgent, config.timezone);       // 1
   registerAgentOps(api, supabase, userId, fallbackAgentId);   // 2
   registerProjectOps(api, supabase, userId);                  // 3
   registerScheduleOps(api, supabase, userId);                 // 4
@@ -5625,22 +5848,19 @@ export function registerTools(
   registerPlanOps(api, supabase, userId, resolveAgent);       // 12
   registerSOPOps(api, supabase, userId, resolveAgent);        // 13
   registerBrainOps(api, supabase, userId, resolveAgent);      // 14
+  registerTalentOps(api, supabase, userId);                   // 15
 
   // ── Register dynamic brain context hook ──
-  // FIX (v4.30.0): Was injectBrainContext() which loaded once at registration.
-  // Now registers a before_prompt_build hook that dynamically resolves the
-  // calling agent from ctx.agentId and loads THAT agent's brain memories.
-  // Each agent sees its own brain context — Daisy sees Daisy's, Ivy sees Ivy's.
   registerBrainContextHook(api, supabase, userId, fallbackAgentId);
 
+  // ── Register talent context hook ──
+  registerTalentContextHook(api, supabase, userId, fallbackAgentId);
+
   // ── Register agent_end hook for server-side brain extraction ──
-  // This is the FIX for Bug 2: extraction was client-side only (useSocket.ts).
-  // Now every completed agent turn — from ANY channel (Telegram, Discord,
-  // webchat, scheduled) — triggers memory extraction server-side.
   registerBrainExtractionHook(api, supabase, userId, fallbackAgentId);
 
   // ── Count and log ──
-  const toolCount = 14;
+  const toolCount = 15;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);

package/src/types.ts

@@ -5,4 +5,6 @@ export interface OfiereConfig {
   userId: string;
   /** Optional — if not set, agent identity is resolved at runtime from OpenClaw context */
   agentId: string;
+  /** IANA timezone string for the user (e.g. 'Asia/Jakarta', 'America/New_York'). Default: 'Asia/Jakarta' */
+  timezone: string;
 }