diff --git a/hyracks-storage-am-lsm-common/src/main/java/edu/uci/ics/hyracks/storage/am/lsm/common/impls/LSMHarness.java b/hyracks-storage-am-lsm-common/src/main/java/edu/uci/ics/hyracks/storage/am/lsm/common/impls/LSMHarness.java
index 9759322..d082a93 100644
--- a/hyracks-storage-am-lsm-common/src/main/java/edu/uci/ics/hyracks/storage/am/lsm/common/impls/LSMHarness.java
+++ b/hyracks-storage-am-lsm-common/src/main/java/edu/uci/ics/hyracks/storage/am/lsm/common/impls/LSMHarness.java
@@ -202,6 +202,7 @@
         List<ILSMComponent> mergedComponents = new ArrayList<ILSMComponent>();
         operation.getCallback().beforeOperation(operation);
         ILSMComponent newComponent = lsmIndex.merge(mergedComponents, operation);
+        ctx.getComponentHolder().addAll(mergedComponents);
         operation.getCallback().afterOperation(operation, mergedComponents, newComponent);
         lsmIndex.markAsValid(newComponent);
         operation.getCallback().afterFinalize(operation, newComponent);
