fix: address code review findings from PR #314

- Simplify orphan concept query to WHERE NOT EXISTS pattern
- Handle 204 No Content in api_client.delete()
- Add test for write-back flush delay threshold

Author: aaronsb

api/app/routes/documents.py

@@ -1130,9 +1130,7 @@ async def delete_document(
         # Clean up orphaned concepts (concepts with no remaining sources)
         orphaned_result = client._execute_cypher("""
             MATCH (c:Concept)
-            OPTIONAL MATCH (c)-[:APPEARS]->(s:Source)
-            WITH c, s
-            WHERE s IS NULL
+            WHERE NOT EXISTS { MATCH (c)-[:APPEARS]->(:Source) }
             DETACH DELETE c
             RETURN count(c) as orphaned_count
         """, fetch_one=True)

fuse/kg_fuse/api_client.py

@@ -74,7 +74,7 @@ async def post(self, path: str, json: dict = None, data: dict = None, files: dic
         response.raise_for_status()
         return response.json()
 
-    async def delete(self, path: str, params: Optional[dict] = None) -> dict:
+    async def delete(self, path: str, params: Optional[dict] = None) -> Optional[dict]:
         """Make authenticated DELETE request to API."""
         token = await self._get_token()
         client = await self._get_client()
@@ -84,6 +84,8 @@ async def delete(self, path: str, params: Optional[dict] = None) -> dict:
             headers={"Authorization": f"Bearer {token}"},
         )
         response.raise_for_status()
+        if response.status_code == 204 or not response.content:
+            return None
         return response.json()
 
     async def get_bytes(self, path: str, params: Optional[dict] = None, timeout: float = 60.0) -> bytes:

fuse/tests/test_lifecycle.py

@@ -2,12 +2,14 @@
 
 import json
 import errno
+import time
 import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pyfuse3
 
 from kg_fuse.config import WriteProtectConfig, TagsConfig, JobsConfig
+from kg_fuse.filesystem import WRITE_BACK_DELAY
 from kg_fuse.models import InodeEntry
 
 
@@ -549,6 +551,36 @@ async def test_rename_non_ingestion_raises_eperm(self):
             await fs.rename(ingest_inode, b"some.concept.md", ingest_inode, b"new.md", 0, ctx)
         assert exc_info.value.errno == errno.EPERM
 
+    @pytest.mark.anyio
+    async def test_flush_skips_entries_below_delay(self):
+        """Flush task should not ingest entries younger than WRITE_BACK_DELAY."""
+        fs = _make_fs()
+        ctx = _mock_ctx()
+        ingest_inode = self._setup_ingest_dir(fs)
+
+        fi, _ = await fs.create(ingest_inode, b"young.md", 0o644, 0, ctx)
+        fh = fi.fh
+        await fs.write(fh, 0, b"content")
+        await fs.release(fh)
+        assert len(fs._pending_ingestions) == 1
+
+        # Simulate flush with entry still young (timestamp = now)
+        ready = [
+            (k, e) for k, e in fs._pending_ingestions.items()
+            if time.monotonic() - e["timestamp"] >= WRITE_BACK_DELAY
+        ]
+        assert len(ready) == 0, "Entry should not be ready yet"
+
+        # Age the entry past the delay
+        for entry in fs._pending_ingestions.values():
+            entry["timestamp"] = time.monotonic() - WRITE_BACK_DELAY - 1
+
+        ready = [
+            (k, e) for k, e in fs._pending_ingestions.items()
+            if time.monotonic() - e["timestamp"] >= WRITE_BACK_DELAY
+        ]
+        assert len(ready) == 1, "Entry should be ready after aging"
+
     @pytest.mark.anyio
     async def test_destroy_flushes_pending(self):
         """Unmount should flush all pending ingestions before cleanup."""