Update mnemo_core.py

mnemo_core.py

@@ -1338,6 +1338,59 @@ class MnemoEngine:
             self._dirty = True
         return True
 
+    def delete_knot(self, knot_id: str) -> bool:
+        """Delete a knot and clean up references from its threads."""
+        with self._lock:
+            knot = self.knots.get(knot_id)
+            if not knot:
+                return False
+            # Remove knot reference from threads
+            for tid in knot.threads:
+                thread = self.threads.get(tid)
+                if thread and knot_id in thread.knots:
+                    thread.knots.remove(knot_id)
+                    thread.invalidate_cache()
+            # Remove from thread_index
+            for tid in knot.threads:
+                knot_list = self.thread_index.by_thread.get(tid, [])
+                if knot_id in knot_list:
+                    knot_list.remove(knot_id)
+            self.thread_index.by_knot.pop(knot_id, None)
+            del self.knots[knot_id]
+            self._dirty = True
+        return True
+
+    def delete_session_threads_and_knots(self, session_id: str) -> dict:
+        """Delete all threads and knots belonging to a session.
+        
+        Called after delete_session_points() to complete cascade.
+        Threads from protected sources (file_upload, manual) are kept.
+        """
+        PROTECTED_SOURCES = {"file_upload", "manual_correction", "consolidation", "manual"}
+        deleted_threads = 0
+        deleted_knots = 0
+
+        # Find threads belonging to this session
+        with self._lock:
+            thread_ids = [tid for tid, t in self.threads.items()
+                         if t.session_id == session_id]
+            knot_ids = [kid for kid, k in self.knots.items()
+                       if k.session_id == session_id]
+
+        for tid in thread_ids:
+            if self.delete_thread(tid):
+                deleted_threads += 1
+
+        for kid in knot_ids:
+            if self.delete_knot(kid):
+                deleted_knots += 1
+
+        if deleted_threads > 0 or deleted_knots > 0:
+            with self._lock:
+                self._dirty = True
+
+        return {"deleted_threads": deleted_threads, "deleted_knots": deleted_knots}
+
     def add_knot(self, knot_id: str, name: str, thread_ids: List[str],
                  pivot_type: str = "collision", reason: str = "",
                  session_id: str = "",
@@ -1928,5 +1981,7 @@ class PersistentMnemo:
     def trace_thread(self, *args, **kwargs): return self.engine.trace_thread(*args, **kwargs)
     def get_active_threads(self): return self.engine.get_active_threads()
     def delete_thread(self, *args, **kwargs): return self.engine.delete_thread(*args, **kwargs)
+    def delete_knot(self, *args, **kwargs): return self.engine.delete_knot(*args, **kwargs)
+    def delete_session_threads_and_knots(self, *args, **kwargs): return self.engine.delete_session_threads_and_knots(*args, **kwargs)
     def add_knot(self, *args, **kwargs): return self.engine.add_knot(*args, **kwargs)
     def get_knot_context(self, *args, **kwargs): return self.engine.get_knot_context(*args, **kwargs)