ofiere-openclaw-plugin 4.18.4 → 4.19.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.18.4",
+  "version": "4.19.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM - 12 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, and execution plan builder",
+  "description": "OpenClaw plugin for Ofiere PM - 13 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, space file management, execution plan builder, and SOP management",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/prompt.ts

@@ -130,6 +130,19 @@ const TOOL_DOCS: Record<string, string> = {
     - Plans are visual DAG drafts — they don't become real tasks until you call "execute"
     - Execution maps ALL node fields into real tasks: execution_steps → custom_fields.execution_plan, goals → custom_fields.goals, constraints → custom_fields.constraints, system_prompt → custom_fields.system_prompt
     - The user can see and edit your plans in the Planning Tab of the dashboard in real-time`,
+
+  OFIERE_SOP_OPS: `- **OFIERE_SOP_OPS** — Standard Operating Procedures for department chiefs (action: "list_templates", "create", "list", "get", "update", "delete", "list_subagents", "apply_template")
+    - list_templates: See available SOP templates (built-in + user-created)
+    - create: Create a new SOP. Required: agent_id, title, sop_data. Optional: department, status
+    - list: List SOPs. Optional: agent_id to filter by department chief
+    - get: Full SOP details with structured content. Required: sop_id
+    - update: Modify SOP content/status. Required: sop_id. Optional: title, sop_data, status, department
+    - delete: Remove an SOP. Required: sop_id
+    - list_subagents: View staff under a chief. Required: chief_agent_id
+    - apply_template: Create SOP from a saved template. Required: agent_id, template_id
+    - sop_data is a JSON object: { title, objective, scope, prerequisites[{text,checked}], steps[{name,action,owner,output}], deliverables[], escalationRules[{trigger,escalateTo,priority}], successCriteria[{text,checked}], notes }
+    - Status values: draft, active, archived
+    - SOPs appear in the SOP Manager page immediately via real-time sync`,
 };
 
 export function getSystemPrompt(state: {
@@ -195,6 +208,12 @@ ${toolDocs}
 - When creating a plan with nodes, nest children inside each node's children[] array. Sequential children execute in order; set parallel: true on a parent node to fork its children into parallel branches.
 - Always call OFIERE_PLAN_OPS action:"get" before action:"add_nodes" or action:"update" to see the current tree structure and node IDs.
 - Execution ("execute") maps plan nodes 1:1 into real PM tasks with ALL enrichment fields preserved: execution_steps, goals, constraints, system_prompt. No data is lost in the handoff.
+- SOP CREATION: When asked to create an SOP, use OFIERE_SOP_OPS action:"create" with a COMPLETE sop_data object. Fill ALL fields with actionable, department-specific content — do NOT leave fields empty.
+- Each SOP step MUST have: a clear name, a specific action description, an assigned owner, and a concrete expected output.
+- Include escalation rules with appropriate priority levels (P1=critical blockers, P2=scope changes, P3=advisory).
+- When creating SOPs for department chiefs (Thalia=CMO, Ivy=COO, Daisy=CTO-Intel, Celia=CTO-Eng), tailor content to their domain expertise.
+- Prerequisites should be actionable checklist items. Success criteria should be measurable outcomes.
+- After creating an SOP, suggest the agent set it to "active" status when ready for execution.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -4442,21 +4442,29 @@ async function handleExecutePlan(
       return idMap.get(n.id);
     }
 
+    // Helper: insert a dependency row into pm_dependencies
+    async function insertDep(predId: string, succId: string): Promise<boolean> {
+      const { error } = await supabase.from("pm_dependencies").insert({
+        id: `dep-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        user_id: userId, predecessor_id: predId, successor_id: succId,
+        dependency_type: "finish_to_start", lag_days: 0,
+      });
+      return !error;
+    }
+
     while (depsQueue.length > 0) {
       const node = depsQueue.shift()!;
       const nodeRealId = resolveTaskId(node);
 
       // Chain siblings: sequential children of this node get chained left-to-right
       if (Array.isArray(node.children) && node.children.length > 1 && !node.parallel) {
-        // Collect task-type children in order for chaining
         const taskChildren: string[] = [];
         for (const child of node.children) {
           const cid = resolveTaskId(child);
           if (cid) taskChildren.push(cid);
         }
         for (let i = 1; i < taskChildren.length; i++) {
-          await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: taskChildren[i - 1], successor_id: taskChildren[i], dependency_type: "finish_to_start", lag_days: 0 });
-          depsCreated++;
+          if (await insertDep(taskChildren[i - 1], taskChildren[i])) depsCreated++;
         }
       }
 
@@ -4464,8 +4472,7 @@ async function handleExecutePlan(
       if (nodeRealId && !node.parallel && node.children?.length > 0) {
         const firstChildId = resolveTaskId(node.children[0]);
         if (firstChildId) {
-          await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: nodeRealId, successor_id: firstChildId, dependency_type: "finish_to_start", lag_days: 0 });
-          depsCreated++;
+          if (await insertDep(nodeRealId, firstChildId)) depsCreated++;
         }
       }
 
@@ -4474,8 +4481,7 @@ async function handleExecutePlan(
         for (const child of node.children) {
           const childId = resolveTaskId(child);
           if (childId) {
-            await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: nodeRealId, successor_id: childId, dependency_type: "finish_to_start", lag_days: 0 });
-            depsCreated++;
+            if (await insertDep(nodeRealId, childId)) depsCreated++;
           }
         }
       }
@@ -4490,8 +4496,7 @@ async function handleExecutePlan(
       if (rid) rootTaskIds.push(rid);
     }
     for (let i = 1; i < rootTaskIds.length; i++) {
-      await supabase.from("task_dependencies").insert({ user_id: userId, predecessor_id: rootTaskIds[i - 1], successor_id: rootTaskIds[i], dependency_type: "finish_to_start", lag_days: 0 });
-      depsCreated++;
+      if (await insertDep(rootTaskIds[i - 1], rootTaskIds[i])) depsCreated++;
     }
 
     // Mark plan as deployed
@@ -4509,6 +4514,338 @@ async function handleExecutePlan(
   } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 13: OFIERE_SOP_OPS — Standard Operating Procedures
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerSOPOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+): void {
+  api.registerTool({
+    name: "OFIERE_SOP_OPS",
+    label: "Ofiere SOP Operations",
+    description:
+      `Create, manage, and deploy Standard Operating Procedures for department chiefs.\n\n` +
+      `Actions:\n` +
+      `- "list_templates": List available SOP templates\n` +
+      `- "create": Create a new SOP for an agent. Required: agent_id, title, sop_data. Optional: department, status\n` +
+      `- "list": List SOPs. Optional: agent_id to filter\n` +
+      `- "get": Get full SOP details. Required: sop_id\n` +
+      `- "update": Modify SOP. Required: sop_id. Optional: title, sop_data, status, department\n` +
+      `- "delete": Remove SOP. Required: sop_id\n` +
+      `- "list_subagents": List subagents for a chief. Required: chief_agent_id\n` +
+      `- "apply_template": Create SOP from template. Required: agent_id, template_id. Optional: title, department\n\n` +
+      `sop_data structure (JSON object):\n` +
+      `{\n` +
+      `  title: string,\n` +
+      `  objective: string (purpose and expected outcome),\n` +
+      `  scope: string (department or domain),\n` +
+      `  prerequisites: [{ text: string, checked: boolean }],\n` +
+      `  steps: [{ id: string, name: string, action: string, owner: string, output: string }],\n` +
+      `  deliverables: [string],\n` +
+      `  escalationRules: [{ trigger: string, escalateTo: string, priority: "P1"|"P2"|"P3" }],\n` +
+      `  successCriteria: [{ text: string, checked: boolean }],\n` +
+      `  notes: string\n` +
+      `}\n\n` +
+      `Status values: "draft", "active", "archived"`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: { type: "string", enum: ["list_templates", "create", "list", "get", "update", "delete", "list_subagents", "apply_template"] },
+        sop_id: { type: "string", description: "SOP ID (required for get, update, delete)" },
+        agent_id: { type: "string", description: "Agent ID (required for create, list filter, apply_template)" },
+        chief_agent_id: { type: "string", description: "Chief agent ID (required for list_subagents)" },
+        template_id: { type: "string", description: "Template ID (required for apply_template)" },
+        title: { type: "string", description: "SOP title" },
+        department: { type: "string", description: "Department name (e.g. Marketing & Revenue)" },
+        status: { type: "string", enum: ["draft", "active", "archived"], description: "SOP status" },
+        sop_data: {
+          type: "object",
+          description: "Structured SOP content — pass a complete SOPData JSON object",
+          properties: {
+            title: { type: "string" },
+            objective: { type: "string" },
+            scope: { type: "string" },
+            prerequisites: { type: "array", items: { type: "object", properties: { text: { type: "string" }, checked: { type: "boolean" } }, required: ["text"] } },
+            steps: { type: "array", items: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, action: { type: "string" }, owner: { type: "string" }, output: { type: "string" } }, required: ["name", "action"] } },
+            deliverables: { type: "array", items: { type: "string" } },
+            escalationRules: { type: "array", items: { type: "object", properties: { trigger: { type: "string" }, escalateTo: { type: "string" }, priority: { type: "string", enum: ["P1", "P2", "P3"] } }, required: ["trigger", "escalateTo"] } },
+            successCriteria: { type: "array", items: { type: "object", properties: { text: { type: "string" }, checked: { type: "boolean" } }, required: ["text"] } },
+            notes: { type: "string" },
+          },
+        },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+      switch (action) {
+        case "list_templates": return handleSOPListTemplates(supabase, userId);
+        case "create": return handleSOPCreate(supabase, userId, resolveAgent, params);
+        case "list": return handleSOPList(supabase, userId, params);
+        case "get": return handleSOPGet(supabase, userId, params);
+        case "update": return handleSOPUpdate(supabase, userId, params);
+        case "delete": return handleSOPDelete(supabase, userId, params);
+        case "list_subagents": return handleSOPListSubagents(supabase, userId, params);
+        case "apply_template": return handleSOPApplyTemplate(supabase, userId, resolveAgent, params);
+        default: return err(`Unknown action "${action}". Valid: list_templates, create, list, get, update, delete, list_subagents, apply_template`);
+      }
+    },
+  });
+}
+
+// ── SOP action handlers ──────────────────────────────────────────────────────
+
+async function handleSOPListTemplates(supabase: SupabaseClient, userId: string): Promise<ToolResult> {
+  try {
+    const { data, error } = await supabase
+      .from("sop_templates")
+      .select("id, name, description, is_default, created_at")
+      .eq("user_id", userId)
+      .order("created_at", { ascending: false });
+    if (error) return err(error.message);
+    return ok({ templates: data || [], count: (data || []).length });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPCreate(
+  supabase: SupabaseClient, userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const agentIdRaw = params.agent_id as string;
+    if (!agentIdRaw) return err("Missing required field: agent_id");
+    const title = params.title as string;
+    if (!title) return err("Missing required field: title");
+
+    // Build the SOPData JSON
+    const sopDataRaw = params.sop_data as Record<string, unknown> | undefined;
+    let sopContent: string;
+
+    if (sopDataRaw) {
+      // Ensure each step has an id
+      const steps = Array.isArray(sopDataRaw.steps)
+        ? (sopDataRaw.steps as any[]).map((s: any, i: number) => ({
+            id: s.id || `step-${Date.now()}-${i}`,
+            name: s.name || "",
+            action: s.action || "",
+            owner: s.owner || "",
+            output: s.output || "",
+          }))
+        : [];
+      const prerequisites = Array.isArray(sopDataRaw.prerequisites)
+        ? (sopDataRaw.prerequisites as any[]).map((p: any) => ({ text: p.text || "", checked: !!p.checked }))
+        : [];
+      const successCriteria = Array.isArray(sopDataRaw.successCriteria)
+        ? (sopDataRaw.successCriteria as any[]).map((c: any) => ({ text: c.text || "", checked: !!c.checked }))
+        : [];
+      const escalationRules = Array.isArray(sopDataRaw.escalationRules)
+        ? (sopDataRaw.escalationRules as any[]).map((r: any) => ({
+            trigger: r.trigger || "",
+            escalateTo: r.escalateTo || r.escalate_to || "",
+            priority: (r.priority || "P2") as "P1" | "P2" | "P3",
+          }))
+        : [];
+      const deliverables = Array.isArray(sopDataRaw.deliverables)
+        ? (sopDataRaw.deliverables as string[])
+        : [];
+
+      const sopData = {
+        title: (sopDataRaw.title as string) || title,
+        objective: (sopDataRaw.objective as string) || "",
+        scope: (sopDataRaw.scope as string) || "",
+        prerequisites,
+        steps,
+        deliverables,
+        escalationRules,
+        successCriteria,
+        notes: (sopDataRaw.notes as string) || "",
+      };
+      sopContent = JSON.stringify(sopData);
+    } else {
+      // Create empty SOP data
+      sopContent = JSON.stringify({
+        title, objective: "", scope: "", prerequisites: [],
+        steps: [{ id: `step-${Date.now()}-0`, name: "", action: "", owner: "", output: "" }],
+        deliverables: [], escalationRules: [], successCriteria: [], notes: "",
+      });
+    }
+
+    const row = {
+      user_id: userId,
+      agent_id: agentIdRaw,
+      title,
+      content: sopContent,
+      status: (params.status as string) || "draft",
+      department: (params.department as string) || null,
+    };
+
+    const { data, error } = await supabase.from("agent_sops").insert(row).select().single();
+    if (error) return err(error.message);
+
+    return ok({
+      message: `SOP "${title}" created for agent ${agentIdRaw}`,
+      sop: { id: data.id, title: data.title, status: data.status, agent_id: data.agent_id, department: data.department },
+    });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPList(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    let query = supabase
+      .from("agent_sops")
+      .select("id, agent_id, title, status, department, created_at, updated_at")
+      .eq("user_id", userId)
+      .order("updated_at", { ascending: false });
+    if (params.agent_id) query = query.eq("agent_id", params.agent_id as string);
+    const { data, error } = await query;
+    if (error) return err(error.message);
+    return ok({ sops: data || [], count: (data || []).length });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPGet(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.sop_id) return err("Missing required field: sop_id");
+    const { data, error } = await supabase
+      .from("agent_sops")
+      .select("*")
+      .eq("id", params.sop_id as string)
+      .eq("user_id", userId)
+      .single();
+    if (error) return err(error.message);
+    if (!data) return err("SOP not found");
+
+    // Parse the content to return structured data
+    let parsedContent: any = {};
+    try { parsedContent = JSON.parse(data.content || "{}"); } catch { /* leave empty */ }
+
+    return ok({ sop: { ...data, content: parsedContent } });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPUpdate(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.sop_id) return err("Missing required field: sop_id");
+    const updates: Record<string, any> = { updated_at: new Date().toISOString() };
+    if (params.title !== undefined) updates.title = params.title;
+    if (params.status !== undefined) updates.status = params.status;
+    if (params.department !== undefined) updates.department = params.department;
+
+    if (params.sop_data) {
+      const sopDataRaw = params.sop_data as Record<string, unknown>;
+      const steps = Array.isArray(sopDataRaw.steps)
+        ? (sopDataRaw.steps as any[]).map((s: any, i: number) => ({
+            id: s.id || `step-${Date.now()}-${i}`,
+            name: s.name || "", action: s.action || "", owner: s.owner || "", output: s.output || "",
+          }))
+        : [];
+      const prerequisites = Array.isArray(sopDataRaw.prerequisites)
+        ? (sopDataRaw.prerequisites as any[]).map((p: any) => ({ text: p.text || "", checked: !!p.checked }))
+        : [];
+      const successCriteria = Array.isArray(sopDataRaw.successCriteria)
+        ? (sopDataRaw.successCriteria as any[]).map((c: any) => ({ text: c.text || "", checked: !!c.checked }))
+        : [];
+      const escalationRules = Array.isArray(sopDataRaw.escalationRules)
+        ? (sopDataRaw.escalationRules as any[]).map((r: any) => ({
+            trigger: r.trigger || "", escalateTo: r.escalateTo || r.escalate_to || "",
+            priority: (r.priority || "P2") as "P1" | "P2" | "P3",
+          }))
+        : [];
+
+      updates.content = JSON.stringify({
+        title: (sopDataRaw.title as string) || (params.title as string) || "",
+        objective: (sopDataRaw.objective as string) || "",
+        scope: (sopDataRaw.scope as string) || "",
+        prerequisites, steps,
+        deliverables: Array.isArray(sopDataRaw.deliverables) ? sopDataRaw.deliverables : [],
+        escalationRules, successCriteria,
+        notes: (sopDataRaw.notes as string) || "",
+      });
+    }
+
+    const { data, error } = await supabase
+      .from("agent_sops").update(updates)
+      .eq("id", params.sop_id as string).eq("user_id", userId)
+      .select("id, title, status").maybeSingle();
+    if (error) return err(error.message);
+    if (!data) return err("SOP not found");
+    return ok({ message: `SOP "${data.title}" updated`, sop: data });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPDelete(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.sop_id) return err("Missing required field: sop_id");
+    const { data, error } = await supabase
+      .from("agent_sops").delete()
+      .eq("id", params.sop_id as string).eq("user_id", userId)
+      .select("id, title").maybeSingle();
+    if (error) return err(error.message);
+    if (!data) return err("SOP not found — nothing deleted");
+    return ok({ message: `SOP "${data.title}" deleted`, deleted: true });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPListSubagents(supabase: SupabaseClient, userId: string, params: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (!params.chief_agent_id) return err("Missing required field: chief_agent_id");
+    const { data, error } = await supabase
+      .from("agent_subagents")
+      .select("id, name, role, codename, color_hex, created_at")
+      .eq("user_id", userId)
+      .eq("chief_agent_id", params.chief_agent_id as string)
+      .order("created_at", { ascending: true });
+    if (error) return err(error.message);
+    return ok({ subagents: data || [], count: (data || []).length, max_allowed: 5 });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleSOPApplyTemplate(
+  supabase: SupabaseClient, userId: string,
+  resolveAgent: (id?: string) => Promise<string | null>,
+  params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    if (!params.agent_id) return err("Missing required field: agent_id");
+    if (!params.template_id) return err("Missing required field: template_id");
+
+    // Fetch template
+    const { data: template, error: tErr } = await supabase
+      .from("sop_templates")
+      .select("name, content")
+      .eq("id", params.template_id as string)
+      .eq("user_id", userId)
+      .single();
+    if (tErr || !template) return err("Template not found");
+
+    const title = (params.title as string) || template.name || "SOP from Template";
+
+    const row = {
+      user_id: userId,
+      agent_id: params.agent_id as string,
+      template_id: params.template_id as string,
+      title,
+      content: template.content, // Template content is already JSON
+      status: "draft",
+      department: (params.department as string) || null,
+    };
+
+    const { data, error } = await supabase.from("agent_sops").insert(row).select().single();
+    if (error) return err(error.message);
+
+    return ok({
+      message: `SOP "${title}" created from template "${template.name}" for agent ${params.agent_id}`,
+      sop: { id: data.id, title: data.title, status: data.status, agent_id: data.agent_id },
+    });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -4538,9 +4875,10 @@ export function registerTools(
   registerConstellationOps(api, supabase, userId);            // 10
   registerFileOps(api, supabase, userId);                     // 11
   registerPlanOps(api, supabase, userId, resolveAgent);       // 12
+  registerSOPOps(api, supabase, userId, resolveAgent);        // 13
 
   // ── Count and log ──
-  const toolCount = 12;
+  const toolCount = 13;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);