ofiere-openclaw-plugin 3.5.5 → 4.1.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "3.5.5",
+  "version": "4.1.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM - 10 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, and constellation agent architecture",
+  "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"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/prompt.ts

@@ -40,17 +40,24 @@ const TOOL_DOCS: Record<string, string> = {
     - create: Add knowledge to the library. Requires: file_name. Optional: content, source, author, credibility_tier
     - update/delete: By document ID`,
 
-  OFIERE_WORKFLOW_OPS: `- **OFIERE_WORKFLOW_OPS** — Automated workflows (action: "list", "get", "create", "update", "delete", "list_runs", "trigger")
+  OFIERE_WORKFLOW_OPS: `- **OFIERE_WORKFLOW_OPS** — Full workflow automation control (13 actions)
     - list: All workflows, filter by status (draft, active, paused, archived)
-    - get: Full workflow details by ID
-    - create: New workflow with name + nodes and edges
-      - Node types: manual_trigger, agent_step, http_request, formatter_step, task_call, variable_set, condition, human_approval, delay, loop, convergence, output, checkpoint, note
-      - Each node: { type, data: { label, ...type-specific fields } }. IDs/positions auto-generated
-      - Edges: { source, target }. A manual_trigger is auto-prepended if no trigger exists
-    - update: Modify workflow (name, description, status, nodes, edges)
+    - get: Full workflow details with all node IDs, types, data, edges — ALWAYS call this before surgical edits
+    - create: New workflow with name + nodes[] and edges[]. A manual_trigger is auto-prepended if missing
+    - update: Replace entire workflow graph (name, description, status, nodes, edges)
     - delete: Remove workflow and all run history
     - list_runs: Recent execution history for a workflow
-    - trigger: Start a workflow run (creates a run record)`,
+    - trigger: Start a workflow run
+    - **add_nodes**: Add new nodes to an existing workflow. Required: workflow_id, nodes[]. Optional: edges[] to connect them
+    - **update_node**: Edit a specific node's data fields (e.g. change task instructions, agentId, template). Required: workflow_id, node_id, data. Only specified fields are changed — others are preserved
+    - **delete_nodes**: Remove specific nodes and all their connected edges. Required: workflow_id, node_ids[]
+    - **add_edges**: Add new connections between existing nodes. Required: workflow_id, edges[]. Each edge: { source, target, sourceHandle?, targetHandle? }
+    - **delete_edges**: Remove specific edges by ID. Required: workflow_id, edge_ids[]
+    - **insert_node_between**: Insert a new node between two connected nodes (auto-rewires edges). Required: workflow_id, source_node_id, target_node_id, node. Use this to add steps in the middle of a flow
+    - Node types: manual_trigger, webhook_trigger, agent_step, formatter_step, http_request, task_call, variable_set, condition, human_approval, delay, loop, convergence, output, checkpoint, note
+    - Key fields: agent_step(agentId, task, responseMode, timeoutSec), formatter_step(template, formatMode), condition(expression, varCheck, operator, varMatch), human_approval(instructions), variable_set(variableName, variableValue, operation)
+    - Edge handles: condition edges use sourceHandle "condition-true"/"condition-false". Loop edges use "loop_body"/"done"
+    - Variables: Use {{prev.nodeId.outputText}} for prior outputs, {{variables.key}} for stored variables`,
 
   OFIERE_NOTIFY_OPS: `- **OFIERE_NOTIFY_OPS** — Notifications (action: "list", "mark_read", "mark_all_read", "delete")
     - list: Recent notifications. unread_only=true for unread only
@@ -130,6 +137,11 @@ ${toolDocs}
 - When creating or editing an agent's architecture, ALWAYS use OFIERE_CONSTELLATION_OPS action:"read_blueprint" first to understand the required structure.
 - When creating a new agent, use OFIERE_CONSTELLATION_OPS action:"create_agent" with all available structured params. The agent will be auto-registered in OpenClaw.
 - When deleting an agent, ALWAYS ask the user for explicit confirmation BEFORE calling OFIERE_CONSTELLATION_OPS action:"delete_agent" with confirm: true. Show them what will be deleted. This action is IRREVERSIBLE.
+- WORKFLOW MASTERY: When modifying existing workflows, ALWAYS call "get" first to see all node IDs and the current graph structure.
+- To add a step in the middle of a flow, use "insert_node_between" with the source and target node IDs. Do NOT rebuild the entire graph.
+- 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.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -1141,6 +1141,17 @@ function registerKnowledgeOps(
   });
 }
 
+// ─── Workflow Mutation Serialization Queue ────────────────────────────────────
+// Prevents parallel mutations on the same workflow from racing (last-write-wins).
+// Each workflow gets a sequential promise chain — mutations queue behind previous ones.
+const _wfLockChain = new Map<string, Promise<any>>();
+function sequentialWorkflowOp<T>(wfId: string, fn: () => Promise<T>): Promise<T> {
+  const prev = _wfLockChain.get(wfId) || Promise.resolve();
+  const next = prev.catch(() => {}).then(fn);
+  _wfLockChain.set(wfId, next.catch(() => {}));
+  return next;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // META-TOOL 6: OFIERE_WORKFLOW_OPS — Workflow Management & Execution
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1155,46 +1166,60 @@ function registerWorkflowOps(
     label: "Ofiere Workflow Operations",
     description:
       `Manage, build, and trigger automated workflows in the Ofiere dashboard.\n\n` +
-      `Actions:\n` +
+      `ACTIONS:\n` +
       `- "list": List all workflows. Optional: status\n` +
-      `- "get": Get workflow details. Required: id\n` +
-      `- "create": Create a workflow WITH nodes and edges. Required: name. Optional: description, nodes, edges, schedule, status\n` +
-      `- "update": Update a workflow. Required: id. Optional: name, description, status, nodes, edges, schedule\n` +
+      `- "get": Get full workflow details including all nodes/edges. Required: id\n` +
+      `- "create": Create a workflow WITH nodes and edges. Required: name. Optional: description, nodes, edges, status\n` +
+      `- "update": Update workflow metadata or replace entire graph. Required: id. Optional: name, description, status, nodes, edges\n` +
       `- "delete": Delete a workflow and its run history. Required: id\n` +
       `- "list_runs": List recent runs. Required: workflow_id. Optional: limit\n` +
-      `- "trigger": Start a workflow run. Required: workflow_id\n\n` +
-      `NODE TYPES (use these exact types when creating nodes):\n` +
+      `- "trigger": Start a workflow run. Required: workflow_id\n` +
+      `- "add_nodes": Add new nodes to an existing workflow. Required: workflow_id, nodes[]\n` +
+      `- "update_node": Edit a specific node's data fields without replacing the graph. Required: workflow_id, node_id, data\n` +
+      `- "delete_nodes": Remove specific nodes and their edges. Required: workflow_id, node_ids[]\n` +
+      `- "add_edges": Add new connections between nodes. Required: workflow_id, edges[]\n` +
+      `- "delete_edges": Remove specific edges. Required: workflow_id, edge_ids[]\n` +
+      `- "insert_node_between": Insert a new node between two connected nodes (auto-rewires edges). Required: workflow_id, source_node_id, target_node_id, node\n\n` +
+      `NODE TYPES & CONFIGURABLE FIELDS:\n` +
       `  TRIGGERS (start of workflow — pick one):\n` +
-      `    - "manual_trigger": User clicks Execute to start\n` +
-      `    - "webhook_trigger": External HTTP request triggers it\n` +
-      `    - "schedule_trigger": Runs on cron schedule. data: { label, cron: "0 9 * * 1-5" }\n` +
+      `    "manual_trigger": { label }\n` +
+      `    "webhook_trigger": { label, triggerName?, webhookPayload? }\n\n` +
       `  STEPS (the work):\n` +
-      `    - "agent_step": Delegates task to an AI agent. data: { label, agentId, task, responseMode: "text", timeoutSec: 120 }\n` +
-      `    - "http_request": Calls an external API. data: { label, method: "GET"|"POST", url }\n` +
-      `    - "formatter_step": Formats/transforms text or JSON. data: { label, template }\n` +
-      `    - "task_call": Runs a saved task. data: { label, agentId, taskId }\n` +
-      `    - "variable_set": Stores data in a variable. data: { label, variableName, variableValue }\n` +
+      `    "agent_step": { label, agentId: string, agentName?: string, task: string (prompt/instructions), responseMode: "text"|"json", timeoutSec: number(120) }\n` +
+      `    "formatter_step": { label, template: string (use {{prev.nodeId.outputText}}), formatMode: "template"|"uppercase"|"lowercase"|"extract_json"|"remove_whitespace", outputKey?: string }\n` +
+      `    "http_request": { label, method: "GET"|"POST"|"PUT"|"PATCH"|"DELETE", url: string, body?: string (JSON), headers?: object, timeoutSec: number(30) }\n` +
+      `    "task_call": { label, agentId: string, taskId: string, taskTitle?: string, agentName?: string, systemPromptOverride?: string }\n` +
+      `    "variable_set": { label, variableName: string, variableValue: string, operation: "set"|"append"|"prepend" }\n\n` +
       `  CONTROL FLOW:\n` +
-      `    - "condition": If/else branch. data: { label, expression }\n` +
-      `    - "human_approval": Pauses for human approval. data: { label, instructions }\n` +
-      `    - "delay": Waits for a set time. data: { label, delaySec: 5 }\n` +
-      `    - "loop": Repeats actions. data: { label, loopType: "count", maxIterations: 3 }\n` +
-      `    - "convergence": Waits for multiple parallel inputs. data: { label, mergeStrategy: "wait_all" }\n` +
+      `    "condition": { label, expression: string (JS), varCheck?: string, operator?: "=="|"!="|"contains"|"not_contains"|"starts_with"|"ends_with"|"is_empty"|"not_empty", varMatch?: string }\n` +
+      `      → EDGES: use sourceHandle "condition-true" and "condition-false" for the two branches\n` +
+      `    "human_approval": { label, instructions: string, checkpointId?: string (for rejection cycle) }\n` +
+      `    "delay": { label, delaySec: number(1-3600) }\n` +
+      `    "loop": { label, loopType: "count"|"for_each", maxIterations: number, iterateOver?: string, checkpointId?: string }\n` +
+      `      → EDGES: use sourceHandle "loop_body" for the loop body path and "done" for the exit path\n` +
+      `    "convergence": { label, mergeStrategy: "wait_all"|"first_arrives" }\n\n` +
       `  END:\n` +
-      `    - "output": Returns final result. data: { label, outputMode: "return" }\n` +
+      `    "output": { label, outputMode: "return"|"notification"|"webhook"|"log", template?: string, webhookUrl?: string, checkpointId?: string }\n\n` +
       `  SPECIAL:\n` +
-      `    - "checkpoint": Loop target marker. data: { label }\n` +
-      `    - "note": Sticky note annotation. data: { label, noteText }\n\n` +
-      `Each node: { type, data: { label, ... }, position?: { x, y } }. IDs and positions are auto-generated if omitted.\n` +
-      `Each edge: { source: "node_id", target: "node_id" }. IDs auto-generated.\n` +
-      `A manual_trigger node is always auto-prepended if no trigger node is included.`,
+      `    "checkpoint": { label } — Loop/cycle target marker\n` +
+      `    "note": { label, noteText: string } — Annotation, does not affect execution\n\n` +
+      `VARIABLE SYNTAX: Use {{prev.nodeId.outputText}} to reference prior node outputs. Use {{variables.key}} for stored variables.\n\n` +
+      `STRUCTURE:\n` +
+      `  Each node: { type, data: { label, ... }, position?: { x, y } }. IDs/positions auto-generated if omitted.\n` +
+      `  Each edge: { source, target, sourceHandle?, targetHandle? }. IDs auto-generated.\n` +
+      `  A manual_trigger node is auto-prepended if no trigger node is included on create.\n\n` +
+      `TIPS:\n` +
+      `  - Use "insert_node_between" to add a step in the middle of an existing flow (e.g. add a review gate between formatter and output).\n` +
+      `  - Use "update_node" to fill in or change a specific node's fields without rebuilding the whole graph.\n` +
+      `  - Use "get" first to see the current graph before making surgical edits.\n` +
+      `  - For condition/loop nodes, specify sourceHandle on edges to control which branch path is taken.`,
     parameters: {
       type: "object",
       required: ["action"],
       properties: {
-        action: { type: "string", enum: ["list", "get", "create", "update", "delete", "list_runs", "trigger"] },
+        action: { type: "string", enum: ["list", "get", "create", "update", "delete", "list_runs", "trigger", "add_nodes", "update_node", "delete_nodes", "add_edges", "delete_edges", "insert_node_between"] },
         id: { type: "string", description: "Workflow ID" },
-        workflow_id: { type: "string", description: "Workflow ID for runs/trigger" },
+        workflow_id: { type: "string", description: "Workflow ID" },
         name: { type: "string", description: "Workflow name" },
         description: { type: "string" },
         nodes: {
@@ -1203,9 +1228,9 @@ function registerWorkflowOps(
             type: "object",
             properties: {
               id: { type: "string", description: "Node ID (auto-generated if omitted)" },
-              type: { type: "string", enum: ["manual_trigger", "webhook_trigger", "schedule_trigger", "agent_step", "formatter_step", "http_request", "task_call", "variable_set", "condition", "human_approval", "delay", "loop", "convergence", "output", "checkpoint", "note"] },
+              type: { type: "string", enum: ["manual_trigger", "webhook_trigger", "agent_step", "formatter_step", "http_request", "task_call", "variable_set", "condition", "human_approval", "delay", "loop", "convergence", "output", "checkpoint", "note"] },
               position: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } },
-              data: { type: "object", description: "Node config — always include a 'label' field. See NODE TYPES above for type-specific fields." },
+              data: { type: "object", additionalProperties: true, description: "Node config — always include a 'label' field. See NODE TYPES above for all configurable fields per type." },
             },
           },
           description: "Workflow graph nodes",
@@ -1218,10 +1243,28 @@ function registerWorkflowOps(
               id: { type: "string", description: "Edge ID (auto-generated if omitted)" },
               source: { type: "string", description: "Source node ID" },
               target: { type: "string", description: "Target node ID" },
+              sourceHandle: { type: "string", description: "Source handle: 'condition-true'/'condition-false' for conditions, 'loop_body'/'done' for loops" },
+              targetHandle: { type: "string", description: "Target handle (rarely needed)" },
             },
           },
-          description: "Connections between nodes. Each edge: { source, target }",
+          description: "Connections between nodes",
+        },
+        // Granular edit params
+        node_id: { type: "string", description: "Specific node ID for update_node" },
+        node_ids: { type: "array", items: { type: "string" }, description: "Node IDs for delete_nodes" },
+        edge_ids: { type: "array", items: { type: "string" }, description: "Edge IDs for delete_edges" },
+        node: {
+          type: "object",
+          description: "Single node definition for insert_node_between. { type, data: { label, ... } }",
+          properties: {
+            type: { type: "string" },
+            data: { type: "object", additionalProperties: true },
+            position: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } },
+          },
         },
+        data: { type: "object", additionalProperties: true, description: "Data fields to merge into a node (for update_node). Only specified fields are changed." },
+        source_node_id: { type: "string", description: "Source node ID for insert_node_between" },
+        target_node_id: { type: "string", description: "Target node ID for insert_node_between" },
         steps: { type: "array", items: { type: "object" }, description: "Legacy V1 step definitions" },
         schedule: { type: "string", description: "Cron expression or schedule" },
         status: { type: "string", enum: ["draft", "active", "paused", "archived"] },
@@ -1232,21 +1275,22 @@ function registerWorkflowOps(
       const action = params.action as string;
 
       // Default data for each node type — ensures dashboard renders them properly
+      // schedule_trigger kept for backward compatibility with existing workflows
       const NODE_DEFAULTS: Record<string, Record<string, any>> = {
         manual_trigger: { label: "Execute Trigger" },
         webhook_trigger: { label: "Webhook Trigger" },
         schedule_trigger: { label: "Schedule Trigger", cron: "0 9 * * 1-5" },
-        agent_step: { label: "Agent Step", agentId: "", task: "", responseMode: "text", timeoutSec: 120 },
-        formatter_step: { label: "Formatter", template: "" },
-        http_request: { label: "HTTP Request", method: "GET", url: "" },
-        task_call: { label: "Task", agentId: "", taskId: "", taskTitle: "", agentName: "" },
-        variable_set: { label: "Set Variable", variableName: "", variableValue: "" },
-        condition: { label: "Condition", expression: "" },
-        human_approval: { label: "Human Approval", instructions: "" },
+        agent_step: { label: "Agent Step", agentId: "", agentName: "", task: "", responseMode: "text", timeoutSec: 120 },
+        formatter_step: { label: "Formatter", template: "", formatMode: "template", outputKey: "" },
+        http_request: { label: "HTTP Request", method: "GET", url: "", body: "", headers: {}, timeoutSec: 30 },
+        task_call: { label: "Task", agentId: "", taskId: "", taskTitle: "", agentName: "", systemPromptOverride: "" },
+        variable_set: { label: "Set Variable", variableName: "", variableValue: "", operation: "set" },
+        condition: { label: "Condition", expression: "", varCheck: "", operator: "==", varMatch: "" },
+        human_approval: { label: "Human Approval", instructions: "", checkpointId: "" },
         delay: { label: "Delay", delaySec: 5 },
-        loop: { label: "Loop", loopType: "count", maxIterations: 3 },
+        loop: { label: "Loop", loopType: "count", maxIterations: 3, iterateOver: "", checkpointId: "" },
         convergence: { label: "Convergence", mergeStrategy: "wait_all" },
-        output: { label: "Output", outputMode: "return" },
+        output: { label: "Output", outputMode: "return", template: "", webhookUrl: "", checkpointId: "" },
         checkpoint: { label: "Checkpoint" },
         note: { label: "Note", noteText: "" },
       };
@@ -1267,6 +1311,42 @@ function registerWorkflowOps(
         };
       }
 
+      // Helper: normalize a single edge with auto-ID
+      function normalizeEdge(e: any, i: number) {
+        return {
+          id: e.id || `edge-${Date.now()}-${i}`,
+          source: e.source,
+          target: e.target,
+          ...(e.sourceHandle ? { sourceHandle: e.sourceHandle } : {}),
+          ...(e.targetHandle ? { targetHandle: e.targetHandle } : {}),
+        };
+      }
+
+      // Helper: fetch current workflow graph
+      async function fetchWorkflow(wfId: string) {
+        const { data, error } = await supabase
+          .from("workflows")
+          .select("*")
+          .eq("id", wfId)
+          .eq("user_id", userId)
+          .single();
+        if (error) return { wf: null, error: error.message };
+        return { wf: data, error: null };
+      }
+
+      // Helper: save updated graph back to DB
+      async function saveGraph(wfId: string, nodes: any[], edges: any[]) {
+        const { data, error } = await supabase
+          .from("workflows")
+          .update({ nodes, edges, updated_at: new Date().toISOString() })
+          .eq("id", wfId)
+          .eq("user_id", userId)
+          .select()
+          .single();
+        if (error) return { wf: null, error: error.message };
+        return { wf: data, error: null };
+      }
+
       switch (action) {
         case "list": {
           let q = supabase.from("workflows").select("*").eq("user_id", userId).order("updated_at", { ascending: false });
@@ -1302,7 +1382,6 @@ function registerWorkflowOps(
               position: { x: 100, y: 200 },
               data: { label: "Execute Trigger" },
             };
-            // Shift all other nodes to the right
             finalNodes = finalNodes.map(n => ({
               ...n,
               position: { x: (n.position?.x || 250) + 200, y: n.position?.y || 200 },
@@ -1310,23 +1389,14 @@ function registerWorkflowOps(
             finalNodes.unshift(triggerNode);
           }
 
-          // Build edges — ensure IDs exist
-          let finalEdges = (params.edges as any[]) || [];
-          finalEdges = finalEdges.map((e: any, i: number) => ({
-            id: e.id || `edge-${Date.now()}-${i}`,
-            source: e.source,
-            target: e.target,
-            ...(e.sourceHandle ? { sourceHandle: e.sourceHandle } : {}),
-            ...(e.targetHandle ? { targetHandle: e.targetHandle } : {}),
-          }));
+          // Build edges
+          let finalEdges = ((params.edges as any[]) || []).map((e: any, i: number) => normalizeEdge(e, i));
 
           // Auto-wire trigger to first non-trigger node if no edge connects from trigger
-          if (hasTrigger === false && finalNodes.length > 1 && finalEdges.length === 0) {
-            // No edges at all — auto-connect trigger → first step
-          } else if (hasTrigger === false && finalNodes.length > 1) {
+          if (!hasTrigger && finalNodes.length > 1) {
             const triggerId = finalNodes[0].id;
             const firstStepId = finalNodes[1].id;
-            const triggerHasEdge = finalEdges.some(e => e.source === triggerId);
+            const triggerHasEdge = finalEdges.some((e: any) => e.source === triggerId);
             if (!triggerHasEdge) {
               finalEdges.unshift({
                 id: `edge-trigger-${Date.now()}`,
@@ -1360,16 +1430,11 @@ function registerWorkflowOps(
           for (const f of ["name", "description", "status", "steps", "schedule", "nodes", "edges"]) {
             if ((params as any)[f] !== undefined) upd[f] = (params as any)[f];
           }
-          // Normalize nodes using the same defaults as create
           if (upd.nodes && Array.isArray(upd.nodes)) {
             upd.nodes = upd.nodes.map((n: any, i: number) => normalizeNode(n, i));
           }
           if (upd.edges && Array.isArray(upd.edges)) {
-            upd.edges = upd.edges.map((e: any, i: number) => ({
-              id: e.id || `edge-${Date.now()}-${i}`,
-              source: e.source,
-              target: e.target,
-            }));
+            upd.edges = upd.edges.map((e: any, i: number) => normalizeEdge(e, i));
           }
           const { data, error } = await supabase.from("workflows").update(upd).eq("id", wfId).eq("user_id", userId).select().single();
           if (error) return err(error.message);
@@ -1378,7 +1443,6 @@ function registerWorkflowOps(
         case "delete": {
           const wfId = (params.id || params.workflow_id) as string;
           if (!wfId) return err("Missing required: id");
-          // Delete associated runs first
           await supabase.from("workflow_runs").delete().eq("workflow_id", wfId);
           const { error } = await supabase.from("workflows").delete().eq("id", wfId).eq("user_id", userId);
           if (error) return err(error.message);
@@ -1401,6 +1465,7 @@ function registerWorkflowOps(
           const { error } = await supabase.from("workflow_runs").insert({
             id: runId,
             workflow_id: wfId,
+            user_id: userId,
             status: "running",
             started_at: new Date().toISOString(),
             trigger_type: "agent",
@@ -1408,8 +1473,276 @@ function registerWorkflowOps(
           if (error) return err(error.message);
           return ok({ message: `Workflow run triggered`, run_id: runId, workflow_id: wfId });
         }
+
+        // ─── Granular Node Operations ────────────────────────────────────
+
+        case "add_nodes": {
+          const wfId = (params.workflow_id || params.id) as string;
+          if (!wfId) return err("Missing required: workflow_id");
+          const newNodes = params.nodes as any[];
+          if (!newNodes || !Array.isArray(newNodes) || newNodes.length === 0) return err("Missing required: nodes[] (array of node definitions)");
+
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+
+            const existingNodes = (wf.nodes as any[]) || [];
+            const existingEdges = (wf.edges as any[]) || [];
+
+            const maxY = existingNodes.reduce((max: number, n: any) => Math.max(max, n.position?.y || 0), 0);
+            const normalized = newNodes.map((n, i) => {
+              const node = normalizeNode(n, existingNodes.length + i);
+              if (!n.position) {
+                node.position = { x: 250, y: maxY + 120 + i * 150 };
+              }
+              return node;
+            });
+
+            const allNodes = [...existingNodes, ...normalized];
+
+            let allEdges = existingEdges;
+            if (params.edges && Array.isArray(params.edges)) {
+              const newEdges = (params.edges as any[]).map((e: any, i: number) => normalizeEdge(e, existingEdges.length + i));
+              allEdges = [...existingEdges, ...newEdges];
+            }
+
+            const { wf: saved, error: saveErr } = await saveGraph(wfId, allNodes, allEdges);
+            if (saveErr) return err(saveErr);
+
+            return ok({
+              message: `Added ${normalized.length} node(s) to workflow`,
+              added_nodes: normalized.map((n: any) => ({ id: n.id, type: n.type, label: n.data?.label })),
+              total_nodes: allNodes.length,
+              total_edges: allEdges.length,
+              workflow: saved,
+            });
+          });
+        }
+
+        case "update_node": {
+          const wfId = (params.workflow_id || params.id) as string;
+          if (!wfId) return err("Missing required: workflow_id");
+          const nodeId = params.node_id as string;
+          if (!nodeId) return err("Missing required: node_id");
+          const dataUpdate = params.data as Record<string, any>;
+          if (!dataUpdate || typeof dataUpdate !== "object") return err("Missing required: data (object with fields to update)");
+
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+
+            const nodes = (wf.nodes as any[]) || [];
+            const nodeIndex = nodes.findIndex((n: any) => n.id === nodeId);
+            if (nodeIndex === -1) return err(`Node "${nodeId}" not found in workflow. Use action "get" to see all node IDs.`);
+
+            // Merge new data into existing node data (preserves untouched fields)
+            const existingData = nodes[nodeIndex].data || {};
+            nodes[nodeIndex].data = { ...existingData, ...dataUpdate };
+
+            if (params.node && typeof params.node === "object" && (params.node as any).position) {
+              nodes[nodeIndex].position = (params.node as any).position;
+            }
+
+            const { wf: saved, error: saveErr } = await saveGraph(wfId, nodes, wf.edges || []);
+            if (saveErr) return err(saveErr);
+
+            return ok({
+              message: `Node "${nodeId}" updated`,
+              node: { id: nodes[nodeIndex].id, type: nodes[nodeIndex].type, data: nodes[nodeIndex].data },
+              fields_updated: Object.keys(dataUpdate),
+              workflow: saved,
+            });
+          });
+        }
+
+        case "delete_nodes": {
+          const wfId = (params.workflow_id || params.id) as string;
+          if (!wfId) return err("Missing required: workflow_id");
+          const nodeIds = params.node_ids as string[];
+          if (!nodeIds || !Array.isArray(nodeIds) || nodeIds.length === 0) return err("Missing required: node_ids[] (array of node IDs to delete)");
+
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+
+            // Track which IDs actually exist vs. not found
+            const existingNodeIdSet = new Set(((wf.nodes as any[]) || []).map((n: any) => n.id));
+            const actuallyDeletedIds = nodeIds.filter(id => existingNodeIdSet.has(id));
+            const notFoundIds = nodeIds.filter(id => !existingNodeIdSet.has(id));
+
+            const nodeIdSet = new Set(nodeIds);
+            const nodes = ((wf.nodes as any[]) || []).filter((n: any) => !nodeIdSet.has(n.id));
+            // Also remove edges connected to deleted nodes
+            const edges = ((wf.edges as any[]) || []).filter((e: any) => !nodeIdSet.has(e.source) && !nodeIdSet.has(e.target));
+
+            const removedEdgeCount = ((wf.edges as any[]) || []).length - edges.length;
+
+            const { wf: saved, error: saveErr } = await saveGraph(wfId, nodes, edges);
+            if (saveErr) return err(saveErr);
+
+            return ok({
+              message: `Deleted ${actuallyDeletedIds.length} node(s) and ${removedEdgeCount} connected edge(s)`,
+              deleted_node_ids: actuallyDeletedIds,
+              not_found_ids: notFoundIds.length > 0 ? notFoundIds : undefined,
+              remaining_nodes: nodes.length,
+              remaining_edges: edges.length,
+              workflow: saved,
+            });
+          });
+        }
+
+        case "add_edges": {
+          const wfId = (params.workflow_id || params.id) as string;
+          if (!wfId) return err("Missing required: workflow_id");
+          const newEdges = params.edges as any[];
+          if (!newEdges || !Array.isArray(newEdges) || newEdges.length === 0) return err("Missing required: edges[] (array of edge definitions)");
+
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+
+            const existingEdges = (wf.edges as any[]) || [];
+            const nodesList = (wf.nodes as any[]) || [];
+            const nodeIdSet = new Set(nodesList.map((n: any) => n.id));
+            const nodesMap = new Map(nodesList.map((n: any) => [n.id, n]));
+
+            try {
+              // Validate source/target existence AND sourceHandle semantics
+              const normalized = newEdges.map((e: any, i: number) => {
+                if (!nodeIdSet.has(e.source)) throw new Error(`Source node "${e.source}" not found in workflow`);
+                if (!nodeIdSet.has(e.target)) throw new Error(`Target node "${e.target}" not found in workflow`);
+
+                // Validate that condition/loop handles are only used on the correct node types
+                if (e.sourceHandle) {
+                  const srcNode = nodesMap.get(e.source);
+                  if (e.sourceHandle.startsWith("condition-") && srcNode?.type !== "condition") {
+                    throw new Error(`sourceHandle "${e.sourceHandle}" is only valid on condition nodes, but source "${e.source}" is type "${srcNode?.type}"`);
+                  }
+                  if ((e.sourceHandle === "loop_body" || e.sourceHandle === "done") && srcNode?.type !== "loop") {
+                    throw new Error(`sourceHandle "${e.sourceHandle}" is only valid on loop nodes, but source "${e.source}" is type "${srcNode?.type}"`);
+                  }
+                }
+
+                return normalizeEdge(e, existingEdges.length + i);
+              });
+
+              const allEdges = [...existingEdges, ...normalized];
+              const { wf: saved, error: saveErr } = await saveGraph(wfId, wf.nodes || [], allEdges);
+              if (saveErr) return err(saveErr);
+
+              return ok({
+                message: `Added ${normalized.length} edge(s)`,
+                added_edges: normalized.map((e: any) => ({ id: e.id, source: e.source, target: e.target })),
+                total_edges: allEdges.length,
+                workflow: saved,
+              });
+            } catch (e: any) {
+              return err(e.message);
+            }
+          });
+        }
+
+        case "delete_edges": {
+          const wfId = (params.workflow_id || params.id) as string;
+          if (!wfId) return err("Missing required: workflow_id");
+          const edgeIds = params.edge_ids as string[];
+          if (!edgeIds || !Array.isArray(edgeIds) || edgeIds.length === 0) return err("Missing required: edge_ids[] (array of edge IDs to delete)");
+
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+
+            // Track which IDs actually exist vs. not found
+            const existingEdgeIds = new Set(((wf.edges as any[]) || []).map((e: any) => e.id));
+            const actuallyDeletedIds = edgeIds.filter(id => existingEdgeIds.has(id));
+            const notFoundIds = edgeIds.filter(id => !existingEdgeIds.has(id));
+
+            const edgeIdSet = new Set(edgeIds);
+            const edges = ((wf.edges as any[]) || []).filter((e: any) => !edgeIdSet.has(e.id));
+
+            const { wf: saved, error: saveErr } = await saveGraph(wfId, wf.nodes || [], edges);
+            if (saveErr) return err(saveErr);
+
+            return ok({
+              message: `Deleted ${actuallyDeletedIds.length} edge(s)`,
+              deleted_edge_ids: actuallyDeletedIds,
+              not_found_ids: notFoundIds.length > 0 ? notFoundIds : undefined,
+              remaining_edges: edges.length,
+              workflow: saved,
+            });
+          });
+        }
+
+        case "insert_node_between": {
+          const wfId = (params.workflow_id || params.id) as string;
+          if (!wfId) return err("Missing required: workflow_id");
+          const sourceId = params.source_node_id as string;
+          const targetId = params.target_node_id as string;
+          const newNodeDef = params.node as any;
+          if (!sourceId) return err("Missing required: source_node_id");
+          if (!targetId) return err("Missing required: target_node_id");
+          if (!newNodeDef || typeof newNodeDef !== "object") return err("Missing required: node (the node definition to insert)");
+
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+
+            const nodes = (wf.nodes as any[]) || [];
+            const edges = (wf.edges as any[]) || [];
+
+            const sourceNode = nodes.find((n: any) => n.id === sourceId);
+            const targetNode = nodes.find((n: any) => n.id === targetId);
+            if (!sourceNode) return err(`Source node "${sourceId}" not found. Use action "get" to see node IDs.`);
+            if (!targetNode) return err(`Target node "${targetId}" not found. Use action "get" to see node IDs.`);
+
+            const connectingEdge = edges.find((e: any) => e.source === sourceId && e.target === targetId);
+            if (!connectingEdge) return err(`No edge found from "${sourceId}" to "${targetId}". They may not be directly connected.`);
+
+            const midX = ((sourceNode.position?.x || 0) + (targetNode.position?.x || 0)) / 2;
+            const midY = ((sourceNode.position?.y || 0) + (targetNode.position?.y || 0)) / 2;
+            const newNode = normalizeNode(
+              { ...newNodeDef, position: newNodeDef.position || { x: midX, y: midY } },
+              nodes.length,
+            );
+
+            const updatedEdges = edges.filter((e: any) => e.id !== connectingEdge.id);
+
+            const edgeIn = {
+              id: `edge-${Date.now()}-in`,
+              source: sourceId,
+              target: newNode.id,
+              ...(connectingEdge.sourceHandle ? { sourceHandle: connectingEdge.sourceHandle } : {}),
+            };
+            const edgeOut = {
+              id: `edge-${Date.now()}-out`,
+              source: newNode.id,
+              target: targetId,
+              ...(connectingEdge.targetHandle ? { targetHandle: connectingEdge.targetHandle } : {}),
+            };
+
+            updatedEdges.push(edgeIn, edgeOut);
+            nodes.push(newNode);
+
+            const { wf: saved, error: saveErr } = await saveGraph(wfId, nodes, updatedEdges);
+            if (saveErr) return err(saveErr);
+
+            return ok({
+              message: `Inserted "${newNode.data.label}" (${newNode.type}) between "${sourceNode.data?.label || sourceId}" and "${targetNode.data?.label || targetId}"`,
+              inserted_node: { id: newNode.id, type: newNode.type, label: newNode.data.label, position: newNode.position },
+              new_edges: [
+                { id: edgeIn.id, from: sourceId, to: newNode.id },
+                { id: edgeOut.id, from: newNode.id, to: targetId },
+              ],
+              removed_edge: connectingEdge.id,
+              total_nodes: nodes.length,
+              total_edges: updatedEdges.length,
+              workflow: saved,
+            });
+          });
+        }
+
         default:
-          return err(`Unknown action "${action}".`);
+          return err(`Unknown action "${action}". Valid: list, get, create, update, delete, list_runs, trigger, add_nodes, update_node, delete_nodes, add_edges, delete_edges, insert_node_between`);
       }
     },
   });