ofiere-openclaw-plugin 4.0.0 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "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/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
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1219,7 +1230,7 @@ function registerWorkflowOps(
               id: { type: "string", description: "Node ID (auto-generated if omitted)" },
               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 all configurable fields per type." },
+              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",
@@ -1247,11 +1258,11 @@ function registerWorkflowOps(
           description: "Single node definition for insert_node_between. { type, data: { label, ... } }",
           properties: {
             type: { type: "string" },
-            data: { type: "object" },
+            data: { type: "object", additionalProperties: true },
             position: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } },
           },
         },
-        data: { type: "object", description: "Data fields to merge into a node (for update_node). Only specified fields are changed." },
+        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" },
@@ -1378,8 +1389,37 @@ function registerWorkflowOps(
             finalNodes.unshift(triggerNode);
           }
 
-          // Build edges
-          let finalEdges = ((params.edges as any[]) || []).map((e: any, i: number) => normalizeEdge(e, i));
+          // Build edges — remap IDs from pre-normalization to post-normalization
+          const idRemap = new Map<string, string>();
+          rawNodes.forEach((raw, i) => {
+            if (raw.id && finalNodes[hasTrigger ? i : i + 1]?.id !== raw.id) {
+              idRemap.set(raw.id, finalNodes[hasTrigger ? i : i + 1].id);
+            }
+          });
+
+          let finalEdges: any[];
+          const suppliedEdges = (params.edges as any[]) || [];
+
+          if (suppliedEdges.length > 0) {
+            // Remap source/target IDs in user-supplied edges
+            finalEdges = suppliedEdges.map((e: any, i: number) => {
+              const remapped = {
+                ...e,
+                source: idRemap.get(e.source) || e.source,
+                target: idRemap.get(e.target) || e.target,
+              };
+              return normalizeEdge(remapped, i);
+            });
+          } else {
+            // No edges supplied — auto-chain all nodes in order
+            finalEdges = [];
+            for (let i = 0; i < finalNodes.length - 1; i++) {
+              finalEdges.push(normalizeEdge({
+                source: finalNodes[i].id,
+                target: finalNodes[i + 1].id,
+              }, i));
+            }
+          }
 
           // Auto-wire trigger to first non-trigger node if no edge connects from trigger
           if (!hasTrigger && finalNodes.length > 1) {
@@ -1387,11 +1427,10 @@ function registerWorkflowOps(
             const firstStepId = finalNodes[1].id;
             const triggerHasEdge = finalEdges.some((e: any) => e.source === triggerId);
             if (!triggerHasEdge) {
-              finalEdges.unshift({
-                id: `edge-trigger-${Date.now()}`,
+              finalEdges.unshift(normalizeEdge({
                 source: triggerId,
                 target: firstStepId,
-              });
+              }, finalEdges.length));
             }
           }
 
@@ -1442,7 +1481,7 @@ function registerWorkflowOps(
           if (!wfId) return err("Missing required: workflow_id");
           const { data, error } = await supabase.from("workflow_runs").select("*")
             .eq("workflow_id", wfId)
-            .order("created_at", { ascending: false })
+            .order("started_at", { ascending: false })
             .limit((params.limit as number) || 20);
           if (error) return err(error.message);
           return ok({ runs: data || [], count: (data || []).length });
@@ -1454,6 +1493,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",
@@ -1470,40 +1510,40 @@ function registerWorkflowOps(
           const newNodes = params.nodes as any[];
           if (!newNodes || !Array.isArray(newNodes) || newNodes.length === 0) return err("Missing required: nodes[] (array of node definitions)");
 
-          const { wf, error: fetchErr } = await fetchWorkflow(wfId);
-          if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+          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 existingNodes = (wf.nodes as any[]) || [];
+            const existingEdges = (wf.edges as any[]) || [];
 
-          // Find the max Y position to place new nodes below existing ones
-          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 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];
+            const allNodes = [...existingNodes, ...normalized];
 
-          // Also add any edges provided
-          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];
-          }
+            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);
+            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,
+            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,
+            });
           });
         }
 
@@ -1515,30 +1555,31 @@ function registerWorkflowOps(
           const dataUpdate = params.data as Record<string, any>;
           if (!dataUpdate || typeof dataUpdate !== "object") return err("Missing required: data (object with fields to update)");
 
-          const { wf, error: fetchErr } = await fetchWorkflow(wfId);
-          if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+          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.`);
+            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
-          const existingData = nodes[nodeIndex].data || {};
-          nodes[nodeIndex].data = { ...existingData, ...dataUpdate };
+            // Merge new data into existing node data (preserves untouched fields)
+            const existingData = nodes[nodeIndex].data || {};
+            nodes[nodeIndex].data = { ...existingData, ...dataUpdate };
 
-          // Also update position if provided
-          if (params.node && typeof params.node === "object" && (params.node as any).position) {
-            nodes[nodeIndex].position = (params.node as any).position;
-          }
+            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);
+            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,
+            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,
+            });
           });
         }
 
@@ -1548,26 +1589,33 @@ function registerWorkflowOps(
           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)");
 
-          const { wf, error: fetchErr } = await fetchWorkflow(wfId);
-          if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
 
-          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));
+            // 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 removedNodeCount = ((wf.nodes as any[]) || []).length - nodes.length;
-          const removedEdgeCount = ((wf.edges as any[]) || []).length - edges.length;
+            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 { wf: saved, error: saveErr } = await saveGraph(wfId, nodes, edges);
-          if (saveErr) return err(saveErr);
+            const removedEdgeCount = ((wf.edges as any[]) || []).length - edges.length;
 
-          return ok({
-            message: `Deleted ${removedNodeCount} node(s) and ${removedEdgeCount} connected edge(s)`,
-            deleted_node_ids: nodeIds,
-            remaining_nodes: nodes.length,
-            remaining_edges: edges.length,
-            workflow: saved,
+            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,
+            });
           });
         }
 
@@ -1577,33 +1625,49 @@ function registerWorkflowOps(
           const newEdges = params.edges as any[];
           if (!newEdges || !Array.isArray(newEdges) || newEdges.length === 0) return err("Missing required: edges[] (array of edge definitions)");
 
-          const { wf, error: fetchErr } = await fetchWorkflow(wfId);
-          if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+          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 nodeIds = new Set(((wf.nodes as any[]) || []).map((n: any) => n.id));
+            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]));
 
-          // Validate that source/target nodes exist
-          const normalized = newEdges.map((e: any, i: number) => {
-            if (!nodeIds.has(e.source)) throw new Error(`Source node "${e.source}" not found in workflow`);
-            if (!nodeIds.has(e.target)) throw new Error(`Target node "${e.target}" not found in workflow`);
-            return normalizeEdge(e, existingEdges.length + i);
-          });
+            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);
+              });
 
-          try {
-            const allEdges = [...existingEdges, ...normalized];
-            const { wf: saved, error: saveErr } = await saveGraph(wfId, wf.nodes || [], allEdges);
-            if (saveErr) return err(saveErr);
+              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);
-          }
+              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": {
@@ -1612,21 +1676,28 @@ function registerWorkflowOps(
           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)");
 
-          const { wf, error: fetchErr } = await fetchWorkflow(wfId);
-          if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+          return sequentialWorkflowOp(wfId, async () => {
+            const { wf, error: fetchErr } = await fetchWorkflow(wfId);
+            if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
 
-          const edgeIdSet = new Set(edgeIds);
-          const edges = ((wf.edges as any[]) || []).filter((e: any) => !edgeIdSet.has(e.id));
-          const removedCount = ((wf.edges as any[]) || []).length - edges.length;
+            // 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 { wf: saved, error: saveErr } = await saveGraph(wfId, wf.nodes || [], edges);
-          if (saveErr) return err(saveErr);
+            const edgeIdSet = new Set(edgeIds);
+            const edges = ((wf.edges as any[]) || []).filter((e: any) => !edgeIdSet.has(e.id));
 
-          return ok({
-            message: `Deleted ${removedCount} edge(s)`,
-            deleted_edge_ids: edgeIds,
-            remaining_edges: edges.length,
-            workflow: saved,
+            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,
+            });
           });
         }
 
@@ -1640,66 +1711,61 @@ function registerWorkflowOps(
           if (!targetId) return err("Missing required: target_node_id");
           if (!newNodeDef || typeof newNodeDef !== "object") return err("Missing required: node (the node definition to insert)");
 
-          const { wf, error: fetchErr } = await fetchWorkflow(wfId);
-          if (fetchErr || !wf) return err(fetchErr || "Workflow not found");
+          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 nodes = (wf.nodes as any[]) || [];
+            const edges = (wf.edges as any[]) || [];
 
-          // Find the source and target nodes
-          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 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.`);
 
-          // Find the edge connecting source → target
-          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 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.`);
 
-          // Create the new node, positioned between source and target
-          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 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,
+            );
 
-          // Remove the original edge
-          const updatedEdges = edges.filter((e: any) => e.id !== connectingEdge.id);
+            const updatedEdges = edges.filter((e: any) => e.id !== connectingEdge.id);
 
-          // Create two new edges: source → newNode and newNode → target
-          const edgeIn = {
-            id: `edge-${Date.now()}-in`,
-            source: sourceId,
-            target: newNode.id,
-            // Preserve the sourceHandle from the original edge (important for condition/loop branches)
-            ...(connectingEdge.sourceHandle ? { sourceHandle: connectingEdge.sourceHandle } : {}),
-          };
-          const edgeOut = {
-            id: `edge-${Date.now()}-out`,
-            source: newNode.id,
-            target: targetId,
-            // Preserve the targetHandle from the original edge
-            ...(connectingEdge.targetHandle ? { targetHandle: connectingEdge.targetHandle } : {}),
-          };
+            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);
+            updatedEdges.push(edgeIn, edgeOut);
+            nodes.push(newNode);
 
-          const { wf: saved, error: saveErr } = await saveGraph(wfId, nodes, updatedEdges);
-          if (saveErr) return err(saveErr);
+            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,
+            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,
+            });
           });
         }