ofiere-openclaw-plugin 4.11.0 → 4.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.11.0",
+  "version": "4.12.1",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 10 meta-tools with 13-action workflow mastery covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, and constellation agent architecture",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/prompt.ts

@@ -9,14 +9,17 @@
 // registered meta-tool and will be included in the system prompt.
 
 const TOOL_DOCS: Record<string, string> = {
-  OFIERE_TASK_OPS: `- **OFIERE_TASK_OPS** — Manage tasks (action: "list", "create", "update", "delete")
+  OFIERE_TASK_OPS: `- **OFIERE_TASK_OPS** — Manage tasks and approvals (action: "list", "create", "update", "delete", "add_approval", "list_approvals", "resolve_approval")
     - list: Filter by status, agent_id, space_id, folder_id, limit. Returns execution_plan, goals, constraints if present
     - create: Requires title. IMPORTANT: Always pass agent_id with your own name to self-assign (e.g. agent_id: "celia")
       - Optional: description, instructions, execution_plan, goals, constraints, system_prompt, priority, tags, dates
       - For COMPLEX tasks: include execution_plan (step-by-step), goals, constraints, and system_prompt
       - For SIMPLE tasks: just title and optionally description
     - update: Requires task_id. All create fields + progress
-    - delete: Requires task_id. Removes task and subtasks`,
+    - delete: Requires task_id. Removes task and subtasks
+    - add_approval: Request sign-off on a task. Requires: task_id, approver_name. Optional: approver_type (human|agent, auto-detected), due_date, comment
+    - list_approvals: List approvals. Optional: task_id to filter, approval_status (pending|approved|rejected)
+    - resolve_approval: Approve or reject. Requires: approval_id, approval_status (approved|rejected). Optional: comment`,
 
   OFIERE_AGENT_OPS: `- **OFIERE_AGENT_OPS** — Query agents (action: "list")
     - list: See all agents with IDs, names, roles for task assignment`,
@@ -142,6 +145,9 @@ ${toolDocs}
 - To change a node's configuration (e.g. update agent instructions, change template text), use "update_node" with just the fields that changed.
 - When creating workflows with condition or loop nodes, specify sourceHandle on edges: "condition-true"/"condition-false" for conditions, "loop_body"/"done" for loops.
 - Fill node data fields with actual content — include real task instructions, templates, and variable references. Do NOT leave fields empty unless intentionally blank.
+- Use add_approval when a task needs sign-off from a human or another agent before proceeding. Approvers can be agents (by name) or humans.
+- Task approvals (OFIERE_TASK_OPS) are SEPARATE from workflow gate approvals (human_approval nodes). Do not confuse them.
+- When an agent completes critical work, consider adding an approval request for human review before marking the task DONE.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -188,17 +188,21 @@ function registerTaskOps(
     name: "OFIERE_TASK_OPS",
     label: "Ofiere Task Operations",
     description:
-      `Manage tasks in the Ofiere PM dashboard. All task operations go through this tool.\n\n` +
+      `Manage tasks and task approvals in the Ofiere PM dashboard. All task operations go through this tool.\n\n` +
       `Actions:\n` +
       `- "list": List/filter tasks. Optional: status, agent_id, space_id, folder_id, task_id, limit\n` +
       `- "get": Get a single task by ID. Required: task_id\n` +
       `- "create": Create a task. Required: title. Optional: agent_id, description, status, priority, space_id, folder_id, start_date, due_date, tags, instructions, execution_plan, goals, constraints, system_prompt, recurrence_type, recurrence_interval, scheduled_time\n` +
       `- "update": Update a task. Required: task_id. Optional: all create fields + progress\n` +
-      `- "delete": Delete task + subtasks. Required: task_id\n\n` +
+      `- "delete": Delete task + subtasks. Required: task_id\n` +
+      `- "add_approval": Request approval on a task. Required: task_id, approver_name. Optional: approver_type (human|agent, auto-detected), due_date, comment\n` +
+      `- "list_approvals": List approvals. Optional: task_id, approval_status filter (pending|approved|rejected)\n` +
+      `- "resolve_approval": Approve or reject. Required: approval_id, approval_status (approved|rejected). Optional: comment\n\n` +
       `For complex tasks, fill in execution_plan (step-by-step plan), goals, constraints, and system_prompt to help the executing agent.\n` +
       `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` +
       `For recurring tasks: set start_date + recurrence_type + recurrence_interval. Example: every 2 minutes = recurrence_type: "minutely", recurrence_interval: 2.\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: {
       type: "object",
@@ -207,7 +211,7 @@ function registerTaskOps(
         action: {
           type: "string",
           description: "The operation to perform",
-          enum: ["list", "get", "create", "update", "delete"],
+          enum: ["list", "get", "create", "update", "delete", "add_approval", "list_approvals", "resolve_approval"],
         },
         title: { type: "string", description: "Task title (required for create)" },
         description: { type: "string", description: "Task description" },
@@ -280,6 +284,19 @@ function registerTaskOps(
         },
         system_prompt: { type: "string", description: "Custom system prompt injection for the executing agent" },
         limit: { type: "number", description: "Max results for list (default 50)" },
+        approver_name: { type: "string", description: "Name of the approver (human name or agent name). Required for add_approval." },
+        approver_type: {
+          type: "string",
+          description: "Whether the approver is a human or an agent. Auto-detected from agents list if omitted.",
+          enum: ["human", "agent"],
+        },
+        approval_id: { type: "string", description: "Approval ID for resolve_approval action" },
+        approval_status: {
+          type: "string",
+          description: "Approval decision: approved or rejected. Used with resolve_approval.",
+          enum: ["approved", "rejected"],
+        },
+        comment: { type: "string", description: "Comment for approval (add_approval or resolve_approval)" },
       },
     },
     async execute(_id: string, params: Record<string, unknown>) {
@@ -297,9 +314,15 @@ function registerTaskOps(
           return handleUpdateTask(supabase, userId, params);
         case "delete":
           return handleDeleteTask(supabase, userId, params);
+        case "add_approval":
+          return handleAddApproval(supabase, userId, params);
+        case "list_approvals":
+          return handleListApprovals(supabase, userId, params);
+        case "resolve_approval":
+          return handleResolveApproval(supabase, userId, params);
         default:
           return err(
-            `Unknown action "${action}". Valid actions: list, get, create, update, delete`,
+            `Unknown action "${action}". Valid actions: list, get, create, update, delete, add_approval, list_approvals, resolve_approval`,
           );
       }
     },
@@ -730,6 +753,189 @@ async function handleDeleteTask(
   }
 }
 
+// ── Approval action handlers ─────────────────────────────────────────────────
+
+async function handleAddApproval(
+  supabase: SupabaseClient,
+  userId: string,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.task_id) return err("Missing required field: task_id");
+    if (!params.approver_name) return err("Missing required field: approver_name");
+
+    const taskId = params.task_id as string;
+    const approverName = params.approver_name as string;
+
+    // Verify task ownership
+    const { data: taskData, error: taskErr } = await supabase
+      .from("tasks")
+      .select("id, title")
+      .eq("id", taskId)
+      .eq("user_id", userId)
+      .single();
+    if (taskErr || !taskData) return err(`Task not found or not owned by you: ${taskId}`);
+
+    // Auto-detect approver_type if not provided
+    let approverType = params.approver_type as string | undefined;
+    if (!approverType) {
+      const { data: agentMatch } = await supabase
+        .from("agents")
+        .select("id")
+        .eq("user_id", userId)
+        .ilike("name", approverName)
+        .limit(1);
+      approverType = (agentMatch && agentMatch.length > 0) ? "agent" : "human";
+    }
+
+    const insertData: Record<string, unknown> = {
+      task_id: taskId,
+      approver_type: approverType,
+      approver_name: approverName,
+      status: "pending",
+    };
+    if (params.due_date) insertData.due_date = params.due_date;
+    if (params.comment) insertData.comment = params.comment;
+
+    const { data, error } = await supabase
+      .from("pm_approvals")
+      .insert(insertData)
+      .select()
+      .single();
+
+    if (error) return err(error.message);
+
+    // Log activity
+    try {
+      await supabase.from("pm_activities").insert({
+        user_id: userId,
+        entity_type: "task",
+        entity_id: taskId,
+        action_type: "approval_requested",
+        source: "agent",
+        source_name: _registrationAgentName || "agent",
+        content: `Requested ${approverType} approval from ${approverName}`,
+        metadata: { approval_id: data.id },
+      });
+    } catch { /* non-fatal */ }
+
+    return ok({
+      message: `Approval requested from ${approverName} (${approverType}) for task "${taskData.title}"`,
+      approval: data,
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+async function handleListApprovals(
+  supabase: SupabaseClient,
+  userId: string,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    // First get all task IDs owned by this user (for ownership guard)
+    const { data: userTasks, error: taskErr } = await supabase
+      .from("tasks")
+      .select("id")
+      .eq("user_id", userId);
+    if (taskErr) return err(taskErr.message);
+
+    const taskIds = (userTasks || []).map((t: { id: string }) => t.id);
+    if (taskIds.length === 0) return ok({ approvals: [], count: 0 });
+
+    let query = supabase
+      .from("pm_approvals")
+      .select("*")
+      .in("task_id", taskIds)
+      .order("created_at", { ascending: false });
+
+    if (params.task_id) query = query.eq("task_id", params.task_id as string);
+    if (params.approval_status) query = query.eq("status", params.approval_status as string);
+
+    const { data, error } = await query;
+    if (error) return err(error.message);
+
+    return ok({ approvals: data || [], count: (data || []).length });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+async function handleResolveApproval(
+  supabase: SupabaseClient,
+  userId: string,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.approval_id) return err("Missing required field: approval_id");
+    if (!params.approval_status) return err("Missing required field: approval_status");
+
+    const approvalId = params.approval_id as string;
+    const newStatus = params.approval_status as string;
+
+    if (!['approved', 'rejected'].includes(newStatus)) {
+      return err(`Invalid approval_status "${newStatus}". Must be "approved" or "rejected".`);
+    }
+
+    // Verify the approval belongs to a task owned by this user
+    const { data: approval, error: fetchErr } = await supabase
+      .from("pm_approvals")
+      .select("id, task_id, approver_name, status")
+      .eq("id", approvalId)
+      .single();
+    if (fetchErr || !approval) return err(`Approval not found: ${approvalId}`);
+
+    // Verify task ownership
+    const { data: taskData, error: taskErr } = await supabase
+      .from("tasks")
+      .select("id, title")
+      .eq("id", approval.task_id)
+      .eq("user_id", userId)
+      .single();
+    if (taskErr || !taskData) return err(`Approval's task not owned by you`);
+
+    if (approval.status !== 'pending') {
+      return err(`Approval already resolved as "${approval.status}". Cannot change.`);
+    }
+
+    const updates: Record<string, unknown> = {
+      status: newStatus,
+      resolved_at: new Date().toISOString(),
+    };
+    if (params.comment !== undefined) updates.comment = params.comment;
+
+    const { error } = await supabase
+      .from("pm_approvals")
+      .update(updates)
+      .eq("id", approvalId);
+
+    if (error) return err(error.message);
+
+    // Log activity
+    try {
+      await supabase.from("pm_activities").insert({
+        user_id: userId,
+        entity_type: "task",
+        entity_id: approval.task_id,
+        action_type: `approval_${newStatus}`,
+        source: "agent",
+        source_name: _registrationAgentName || "agent",
+        content: `${newStatus === 'approved' ? 'Approved' : 'Rejected'} approval from ${approval.approver_name}${params.comment ? `: ${params.comment}` : ''}`,
+        metadata: { approval_id: approvalId },
+      });
+    } catch { /* non-fatal */ }
+
+    return ok({
+      message: `Approval ${approvalId} ${newStatus} for task "${taskData.title}"`,
+      approval_id: approvalId,
+      status: newStatus,
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // META-TOOL 2: OFIERE_AGENT_OPS — Agent Management
 // ═══════════════════════════════════════════════════════════════════════════════