fix(core): enable reliable and asynchronous LLM enrichment for all knowledge types

- BackgroundWorker: Now calls 'run_maintenance()' instead of individual methods to ensure the enrichment queue is processed asynchronously.
- Transitions: Relaxed the I1 immutability constraint to allow the enrichment worker to safely update the 'rationale' field of decisions.
- LLMEnricher: Fixed the CLI prompt execution to explicitly force the 'gemini-2.5-flash-lite' model and avoid resource exhaustion.
- LLMEnricher: Ordered evidence event IDs to process oldest first and limited the log payload to 100 events to prevent ARG_MAX overflow.
- EpisodicStore: Fixed a Row conversion TypeError that broke the 'get_by_ids' method and prevented log fetching.

Author: sl4m3

src/ledgermind/core/reasoning/llm_enrichment.py

@@ -85,7 +85,9 @@ def process_batch(self, memory: Any):
                 is_procedural = hasattr(proposal, 'procedural') and proposal.procedural and proposal.procedural.steps
 
                 if not is_procedural and proposal.evidence_event_ids:
-                    events = memory.episodic.get_by_ids(proposal.evidence_event_ids)
+                    # Sort IDs to get oldest first, and limit to 100 to prevent context overflow
+                    sorted_ids = sorted(proposal.evidence_event_ids)
+                    events = memory.episodic.get_by_ids(sorted_ids[:100])
                     log_entries = []
                     for ev in events:
                         log_entries.append(f"[{ev['kind'].upper()}] {ev['content']}")

src/ledgermind/core/stores/episodic.py

@@ -148,8 +148,24 @@ def get_by_ids(self, ids: List[int]) -> List[Dict[str, Any]]:
         query = sql_template.format(placeholders)
 
         with self._get_conn() as conn:
-            rows = conn.execute(query, ids).fetchall()
-            return [dict(row) for row in rows]
+            cursor = conn.execute(query, ids)
+            rows = cursor.fetchall()
+            
+            # Ensure we can return a list of dicts regardless of row factory behavior
+            cols = [col[0] for col in cursor.description] if cursor.description else ["id", "source", "kind", "content", "context", "timestamp", "status", "linked_id", "link_strength"]
+            
+            result = []
+            for row in rows:
+                if isinstance(row, dict):
+                    result.append(row)
+                elif hasattr(row, 'keys'):
+                    result.append(dict(row))
+                elif hasattr(row, '_mapping'):
+                    result.append(dict(row._mapping))
+                else:
+                    # It's a tuple
+                    result.append(dict(zip(cols, row)))
+            return result
 
     def query(self, limit: int = 100, status: Optional[str] = 'active', after_id: Optional[int] = None, order: str = 'DESC') -> List[Dict[str, Any]]:
         with self._get_conn() as conn:

src/ledgermind/core/stores/semantic_store/transitions.py

@@ -53,6 +53,9 @@ def is_minor_diff(s1, s2):
                 # Proposals are hypotheses, allow updating rationale as more evidence arrives
                 if old_data.get("kind") == "proposal":
                     continue
+                # Allow LLM enrichment to update rationale even on decisions
+                if field == "rationale" and old_ctx.get("enrichment_status") == "pending":
+                    continue
                 raise TransitionError(f"I1 Violation: Semantic context field '{field}' is immutable. Change rejected.")
 
         # Also, check kind-specific constraints

src/ledgermind/server/background.py

@@ -53,11 +53,8 @@ def _loop(self):
                 # 2. Git Sync (Ingest external changes)
                 self._run_git_sync()
 
-                # 3. Reflection Cycle (Generate proposals)
-                self._run_reflection()
-                
-                # 4. Decay Cycle (Prune old data)
-                self._run_decay()
+                # 3. Full Maintenance Cycle (Reflection, Decay, Enrichment, Integrity)
+                self._run_maintenance()
 
                 elapsed = time.time() - start_time
                 sleep_time = max(1.0, self.interval - elapsed)
@@ -114,34 +111,28 @@ def _run_git_sync(self):
             if "no such table" in str(e).lower(): raise e
             logger.warning(f"Git sync failed: {e}")
 
-    def _run_reflection(self):
-        """Runs the incremental reflection cycle to generate proposals."""
+    def _run_maintenance(self):
+        """Runs the full maintenance cycle including reflection, decay, and enrichment."""
         try:
-            # Reflection is now incremental and cheap, run it every 5 minutes
-            last = self.last_run.get("reflection")
+            # Run full maintenance every 5 minutes
+            last = self.last_run.get("maintenance")
             now = datetime.now()
 
             if not last or (now - last).total_seconds() > 300: # 5 minutes
-                proposals = self.memory.run_reflection()
-                if proposals:
-                    logger.info(f"Background Reflection: Generated/Updated {len(proposals)} proposals.")
+                report = self.memory.run_maintenance()
 
-                self.last_run["reflection"] = now
-        except Exception as e:
-            if "no such table" in str(e).lower(): raise e
-            logger.error(f"Reflection cycle failed: {e}")
-
-    def _run_decay(self):
-        """Runs the decay cycle to prune old data."""
-        try:
-             # Run decay every 1 hour
-            last = self.last_run.get("decay")
-            now = datetime.now()
-            if not last or (now - last).total_seconds() > 3600: # 1 hour
-                report = self.memory.run_decay()
-                if (isinstance(getattr(report, 'archived', None), int) and report.archived > 0) or (isinstance(getattr(report, 'pruned', None), int) and report.pruned > 0):
-                    logger.info(f"Background Decay: Archived {report.archived}, Pruned {report.pruned}")
-                self.last_run["decay"] = now
+                refl_count = report.get("reflection", {}).get("proposals_created", 0)
+                decay_archived = report.get("decay", {}).get("archived", 0)
+                decay_pruned = report.get("decay", {}).get("pruned", 0)
+                
+                msgs = []
+                if refl_count > 0: msgs.append(f"Reflected {refl_count} items")
+                if decay_archived > 0 or decay_pruned > 0: msgs.append(f"Decayed (Arch: {decay_archived}, Prun: {decay_pruned})")
+                
+                if msgs:
+                    logger.info(f"Background Maintenance: {', '.join(msgs)}")
+                
+                self.last_run["maintenance"] = now
         except Exception as e:
             if "no such table" in str(e).lower(): raise e
-            logger.error(f"Decay cycle failed: {e}")
+            logger.error(f"Maintenance cycle failed: {e}")