know-do-graph 0.1.5__tar.gz → 0.1.6__tar.gz

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: know-do-graph
-Version: 0.1.5
+Version: 0.1.6
 Summary: A wiki-native, agent-oriented infrastructure for executable knowledge, operational memory, and capability discovery.
 Requires-Python: >=3.10
 Requires-Dist: duckduckgo-search>=6.0
@@ -187,6 +187,7 @@ with KnowDoGraph("data/my_agent.db") as graph:
         threshold=20,
         policy=policy,
         strategy="auto",
+        include_existing=True,
         model="qwen-plus",
     )
 ```
@@ -196,9 +197,10 @@ and similar entries. `global` prioritizes under-reviewed, isolated, and highly
 connected nodes using graph statistics. Policy checks run inside every review
 mutation tool; protected nodes may still be linked but cannot be changed,
 deleted, distilled, merged, or have review metadata updated. The automatic
-scheduler counts nodes created through this `KnowDoGraph` client and runs in a
-background thread when the threshold is reached. Call `scheduler.stop()` to
-disable it.
+scheduler counts eligible, unreviewed nodes created through this `KnowDoGraph`
+client and runs in a background thread when the threshold is reached. Set
+`include_existing=True` to count an existing eligible backlog when the
+scheduler is attached. Call `scheduler.stop()` to disable it.
 
 Review raw memory separately and receive structured progress/results:
 

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/README.md

@@ -164,6 +164,7 @@ with KnowDoGraph("data/my_agent.db") as graph:
         threshold=20,
         policy=policy,
         strategy="auto",
+        include_existing=True,
         model="qwen-plus",
     )
 ```
@@ -173,9 +174,10 @@ and similar entries. `global` prioritizes under-reviewed, isolated, and highly
 connected nodes using graph statistics. Policy checks run inside every review
 mutation tool; protected nodes may still be linked but cannot be changed,
 deleted, distilled, merged, or have review metadata updated. The automatic
-scheduler counts nodes created through this `KnowDoGraph` client and runs in a
-background thread when the threshold is reached. Call `scheduler.stop()` to
-disable it.
+scheduler counts eligible, unreviewed nodes created through this `KnowDoGraph`
+client and runs in a background thread when the threshold is reached. Set
+`include_existing=True` to count an existing eligible backlog when the
+scheduler is attached. Call `scheduler.stop()` to disable it.
 
 Review raw memory separately and receive structured progress/results:
 

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/agents/review_agent/tools.py

@@ -83,7 +83,12 @@ def sample_nodes_for_review(
         all_entries = engine.list_entries(limit=5000)
 
     policy = _policy_or_default(policy)
-    candidates = [entry for entry in all_entries if entry.entry_type not in policy.exclude_types]
+    candidates = [
+        entry
+        for entry in all_entries
+        if entry.entry_type not in policy.exclude_types
+        and entry.metadata.verification_status not in policy.protected_statuses
+    ]
     if not candidates or batch_size <= 0:
         return []
 
@@ -125,7 +130,11 @@ def sample_nodes_for_review(
                 seed.title, limit=batch_size * 2, mode="hybrid"
             )
         for entry in similar:
-            if entry.entry_type in policy.exclude_types or entry.id in selected_ids:
+            if (
+                entry.entry_type in policy.exclude_types
+                or entry.metadata.verification_status in policy.protected_statuses
+                or entry.id in selected_ids
+            ):
                 continue
             selected.append(entry)
             selected_ids.add(entry.id)

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/core/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.5'
-__version_tuple__ = version_tuple = (0, 1, 5)
+__version__ = version = '0.1.6'
+__version_tuple__ = version_tuple = (0, 1, 6)
 
 __commit_id__ = commit_id = None

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/know_do_graph/__init__.py

@@ -16,7 +16,7 @@ from core.version import __version__
 
 from .chat import ChatSession
 from .client import KDG, KnowDoGraph
-from .review import AutoReviewScheduler, ReviewPolicy, ReviewStrategy
+from .review import AutoReviewScheduler, ReviewPolicy, ReviewStrategy, is_review_candidate
 
 __all__ = [
     "Edge",
@@ -35,6 +35,7 @@ __all__ = [
     "RefinementStatus",
     "ReviewPolicy",
     "ReviewStrategy",
+    "is_review_candidate",
     "ScriptAttachment",
     "SkillLevel",
     "VerificationStatus",

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/know_do_graph/client.py

@@ -308,9 +308,10 @@ class KnowDoGraph:
         threshold: int = 20,
         policy: "ReviewPolicy | None" = None,
         strategy: "ReviewStrategy" = "auto",
+        include_existing: bool = False,
         **chat_options: Any,
     ) -> Any:
-        """Schedule a background review after each threshold of newly created nodes."""
+        """Schedule a background review after each threshold of eligible nodes."""
         from .review import AutoReviewScheduler
 
         scheduler = AutoReviewScheduler(
@@ -321,6 +322,9 @@ class KnowDoGraph:
             chat_options=chat_options,
         )
         self._auto_reviewers.append(scheduler)
+        if include_existing:
+            with self._session() as db:
+                scheduler.include_existing(EntryRepository(db).get_all())
         return scheduler
 
     def _session(self) -> Session:

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/know_do_graph/review.py

@@ -66,6 +66,15 @@ class ReviewPolicy:
         object.__setattr__(self, "allowed_actions", frozenset(self.allowed_actions))
 
 
+def is_review_candidate(entry: Any, policy: ReviewPolicy) -> bool:
+    """Return whether an entry should count toward an automatic review."""
+    return (
+        entry.entry_type not in policy.exclude_types
+        and entry.metadata.verification_status not in policy.protected_statuses
+        and entry.metadata.review_count == 0
+    )
+
+
 class AutoReviewScheduler:
     """Threshold scheduler returned by :meth:`KnowDoGraph.auto_review`."""
 
@@ -92,11 +101,23 @@ class AutoReviewScheduler:
         self._running = False
         self._lock = Lock()
 
-    def notify_node_created(self, _entry: Any) -> None:
+    def notify_node_created(self, entry: Any) -> None:
+        if not is_review_candidate(entry, self.policy):
+            return
+        self._add_candidates(1)
+
+    def include_existing(self, entries: Any) -> None:
+        """Count existing eligible entries and schedule a review if needed."""
+        count = sum(is_review_candidate(entry, self.policy) for entry in entries)
+        self._add_candidates(count)
+
+    def _add_candidates(self, count: int) -> None:
+        if count <= 0:
+            return
         with self._lock:
             if not self._active:
                 return
-            self.created_since_review += 1
+            self.created_since_review += count
             if self.created_since_review < self.threshold or self._running:
                 return
             self.created_since_review = 0

{know_do_graph-0.1.5 → know_do_graph-0.1.6}/tests/test_public_api.py

@@ -208,6 +208,8 @@ class PublicApiTests(unittest.TestCase):
             )
 
         self.assertNotIn(memory.id, {item["id"] for item in sampled})
+        self.assertNotIn(protected.id, {item["id"] for item in sampled})
+        self.assertIn(ordinary.id, {item["id"] for item in sampled})
         self.assertIn("protected", denied["error"])
         self.assertEqual(assigned["verification_status"], "bugged")
         self.assertIn("not permitted", deletion["error"])
@@ -262,6 +264,75 @@ class PublicApiTests(unittest.TestCase):
         scheduler.stop()
         self.assertNotIn(scheduler, self.graph._auto_reviewers)
 
+    def test_auto_review_counts_only_policy_candidates(self) -> None:
+        from agents.review_agent.tools import mark_reviewed
+        from core.storage.database import bind_session_factory
+
+        policy = ReviewPolicy(
+            exclude_types={EntryType.memory},
+            protected_statuses={VerificationStatus.peer_reviewed},
+        )
+        reviewed = self.graph.add("Already reviewed")
+        with bind_session_factory(self.graph._session_factory):
+            mark_reviewed(reviewed.id, graph=self.graph._graph, policy=policy)
+
+        with patch("know_do_graph.review.Thread") as thread:
+            scheduler = self.graph.auto_review(threshold=1, policy=policy)
+            self.graph.add("Excluded memory", entry_type=EntryType.memory)
+            self.graph.add(
+                "Protected node",
+                metadata=EntryMetadata(
+                    verification_status=VerificationStatus.peer_reviewed
+                ),
+            )
+            scheduler.notify_node_created(self.graph.get(reviewed.id))
+
+            thread.assert_not_called()
+            self.graph.add("Eligible node")
+
+        thread.assert_called_once()
+        scheduler.stop()
+
+    def test_auto_review_can_include_existing_backlog(self) -> None:
+        self.graph.add("Existing candidate one")
+        self.graph.add("Existing candidate two")
+
+        with patch("know_do_graph.review.Thread") as thread:
+            default_scheduler = self.graph.auto_review(threshold=2)
+            thread.assert_not_called()
+            backlog_scheduler = self.graph.auto_review(
+                threshold=2,
+                include_existing=True,
+            )
+
+        thread.assert_called_once()
+        self.assertEqual(backlog_scheduler.created_since_review, 0)
+        default_scheduler.stop()
+        backlog_scheduler.stop()
+
+    def test_auto_review_existing_backlog_respects_policy(self) -> None:
+        self.graph.add("Existing memory", entry_type=EntryType.memory)
+        protected = self.graph.add("Existing protected node")
+        self.graph.set_verification_status(
+            protected.id, VerificationStatus.peer_reviewed
+        )
+        self.graph.add("Existing eligible node")
+        policy = ReviewPolicy(
+            exclude_types={EntryType.memory},
+            protected_statuses={VerificationStatus.peer_reviewed},
+        )
+
+        with patch("know_do_graph.review.Thread") as thread:
+            scheduler = self.graph.auto_review(
+                threshold=2,
+                policy=policy,
+                include_existing=True,
+            )
+
+        thread.assert_not_called()
+        self.assertEqual(scheduler.created_since_review, 1)
+        scheduler.stop()
+
     def test_chat_tools_are_bound_to_the_client_database(self) -> None:
         self.graph.add("Client-owned entry")
         fake_module = ModuleType("agents.graph_agent.agent")