diff --git a/src/main/java/org/perlonjava/backend/jvm/EmitStatement.java b/src/main/java/org/perlonjava/backend/jvm/EmitStatement.java
index 7d2eba823..824cd0d45 100644
--- a/src/main/java/org/perlonjava/backend/jvm/EmitStatement.java
+++ b/src/main/java/org/perlonjava/backend/jvm/EmitStatement.java
@@ -41,7 +41,7 @@ public class EmitStatement {
     static void emitScopeExitNullStores(EmitterContext ctx, int scopeIndex, boolean closeIO) {
         if (closeIO) {
             // For scalar variables in loop bodies, call cleanup to close IO
-            // on anonymous globs (deterministic DESTROY for lexical file handles).
+            // on anonymous globs and fire DESTROY on blessed objects.
             java.util.List<Integer> scalarIndices = ctx.symbolTable.getMyScalarIndicesInScope(scopeIndex);
             for (int idx : scalarIndices) {
                 ctx.mv.visitVarInsn(Opcodes.ALOAD, idx);
@@ -60,7 +60,7 @@ static void emitScopeExitNullStores(EmitterContext ctx, int scopeIndex, boolean
         }
     }
 
-    /** Convenience overload: null stores only, no IO cleanup (safe for all contexts). */
+    /** Convenience overload: null stores only, no IO/DESTROY cleanup (safe for all contexts). */
     static void emitScopeExitNullStores(EmitterContext ctx, int scopeIndex) {
         emitScopeExitNullStores(ctx, scopeIndex, false);
     }
diff --git a/src/main/java/org/perlonjava/core/Configuration.java b/src/main/java/org/perlonjava/core/Configuration.java
index 83e109aea..e2971cf28 100644
--- a/src/main/java/org/perlonjava/core/Configuration.java
+++ b/src/main/java/org/perlonjava/core/Configuration.java
@@ -33,7 +33,7 @@ public final class Configuration {
      * Automatically populated by Gradle/Maven during build.
      * DO NOT EDIT MANUALLY - this value is replaced at build time.
      */
-    public static final String gitCommitId = "92020251e";
+    public static final String gitCommitId = "865da3648";
 
     /**
      * Git commit date of the build (ISO format: YYYY-MM-DD).
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeBase.java b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeBase.java
index 5f31511d9..998a9ea39 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeBase.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeBase.java
@@ -13,6 +13,10 @@ public abstract class RuntimeBase implements DynamicState, Iterable<RuntimeScala
     // Index to the class that this reference belongs
     public int blessId;
 
+    // Guard flag to prevent calling DESTROY more than once on the same object.
+    // Set to true after DESTROY has been called (or is being called).
+    public boolean destroyCalled;
+
     /**
      * Adds this entity to the specified RuntimeList.
      *
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeHash.java b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeHash.java
index 2042f55f3..22723c046 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeHash.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeHash.java
@@ -413,6 +413,11 @@ public RuntimeScalar delete(RuntimeScalar key) {
                 var value = elements.remove(k);
                 if (byteKeys != null) byteKeys.remove(k);
                 if (value != null) {
+                    // Call DESTROY on blessed references being removed from a hash.
+                    // In Perl, delete() on the last reference triggers DESTROY.
+                    // Without ref counting, we call it eagerly; the destroyCalled
+                    // flag on RuntimeBase prevents double-DESTROY.
+                    RuntimeScalar.callDestroyIfNeeded(value);
                     yield new RuntimeScalar(value);
                 }
                 yield new RuntimeScalar();
@@ -432,6 +437,7 @@ public RuntimeScalar delete(String key) {
                 var value = elements.remove(key);
                 if (byteKeys != null) byteKeys.remove(key);
                 if (value != null) {
+                    RuntimeScalar.callDestroyIfNeeded(value);
                     yield new RuntimeScalar(value);
                 }
                 yield new RuntimeScalar();
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeScalar.java b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeScalar.java
index 5aacbf673..52fe7bc4c 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeScalar.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeScalar.java
@@ -1746,6 +1746,9 @@ public RuntimeScalar undefine() {
             InheritanceResolver.invalidateCache();
             return this;
         }
+        // Call DESTROY on blessed references before clearing.
+        // undef $obj explicitly discards the reference, so DESTROY should fire.
+        callDestroyIfNeeded(this);
         // Close IO handles when dropping a glob reference.
         // This mimics Perl's internal sv_clear behavior where IO handles are closed
         // when the glob's reference count drops to zero (independent of DESTROY).
@@ -1840,6 +1843,55 @@ public static void scopeExitCleanup(RuntimeScalar scalar) {
                 }
             }
         }
+        // Also handle blessed references with DESTROY methods.
+        // When a lexical variable holding a blessed reference goes out of scope,
+        // call DESTROY on the object. This is an approximation of Perl's
+        // reference-counted DESTROY: without ref counting, we may call DESTROY
+        // early if other references exist. The destroyCalled flag prevents
+        // double-DESTROY.
+        callDestroyIfNeeded(scalar);
+    }
+
+    /**
+     * Calls DESTROY on a blessed object if:
+     * 1. The scalar holds a blessed reference (blessId != 0)
+     * 2. DESTROY hasn't been called yet on this object (destroyCalled flag)
+     * 3. The class hierarchy defines a DESTROY method
+     * <p>
+     * Perl semantics: DESTROY exceptions are caught and warned "(in cleanup)".
+     * DESTROY is called with the blessed reference as $_[0].
+     * <p>
+     * Note: Without reference counting, this may call DESTROY while other
+     * references to the object still exist. The destroyCalled flag on
+     * RuntimeBase prevents double-DESTROY.
+     */
+    public static void callDestroyIfNeeded(RuntimeScalar scalar) {
+        if (scalar == null) return;
+        int blessId = RuntimeScalarType.blessedId(scalar);
+        if (blessId == 0) return;
+        RuntimeBase base = (RuntimeBase) scalar.value;
+        if (base.destroyCalled) return;
+        base.destroyCalled = true;
+
+        String className = NameNormalizer.getBlessStr(blessId);
+        RuntimeScalar destroyMethod = InheritanceResolver.findMethodInHierarchy(
+                "DESTROY", className, null, 0);
+        if (destroyMethod == null || destroyMethod.type != CODE) {
+            base.destroyCalled = false;  // No DESTROY found, allow future attempts
+            return;
+        }
+
+        try {
+            // Call DESTROY($self) in void context
+            RuntimeArray args = new RuntimeArray();
+            args.push(scalar);
+            RuntimeCode.apply(destroyMethod, args, RuntimeContextType.VOID);
+        } catch (Exception e) {
+            // Perl: DESTROY exceptions are turned into warnings
+            String msg = e.getMessage();
+            if (msg == null) msg = e.getClass().getName();
+            Warnings.warn(new RuntimeArray(new RuntimeScalar("(in cleanup) " + msg + "\n")), RuntimeContextType.VOID);
+        }
     }
 
     public RuntimeScalar defined() {