feat: vector search fusion + quality feedback loop + enhanced memory stats

- F1: Vector search integrated into MemoryPipeline.read() via RRF fusion
  - Auto-indexes existing memories on pipeline initialization
  - Falls back gracefully if sentence-transformers not installed

- F2: Memory quality feedback loop closes the outermost learning cycle
  - Task success → injected memory usage_count += 2 (positive reinforcement)
  - Task failure → gentle decay (usage_count -= 1, possible misdirection)
  - pipeline.feedback(success, injected_ids) called after task completion

- F3: Enhanced /memory stats CLI with tier distribution bars + domain
  breakdown + curator insight count

718 tests passed, 2 skipped

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: QUSETIONS

minicode/memory.py

@@ -1481,18 +1481,53 @@ def get_stats(self) -> dict[str, Any]:
         }
 
     def format_stats(self) -> str:
-        """Format memory stats for display."""
-        stats = self.get_stats()
-        lines = ["Memory System Status", "=" * 40, ""]
-        
-        for scope_name, scope_stats in stats.items():
-            lines.append(f"{scope_name.title()} Memory:")
-            lines.append(f"  Entries: {scope_stats['entries']}")
-            lines.append(f"  Size: {scope_stats['size_bytes'] / 1024:.1f} KB")
-            if scope_stats['categories']:
-                lines.append(f"  Categories: {', '.join(scope_stats['categories'][:5])}")
+        """Format memory stats for display with tier and domain breakdown."""
+        from collections import Counter
+
+        lines = ["Memory System Status", "=" * 50, ""]
+        tiers: Counter[str] = Counter()
+        domains: Counter[str] = Counter()
+        total_entries = 0
+        total_size = 0
+        insight_count = 0
+
+        for scope_name, scope_stats in self.get_stats().items():
+            lines.append(f"{scope_name.title()}: {scope_stats['entries']} entries, "
+                        f"{scope_stats['size_bytes'] / 1024:.1f} KB")
+            total_entries += scope_stats["entries"]
+            total_size += scope_stats["size_bytes"]
+
+            # Collect tier and domain stats
+            scope = MemoryScope(scope_name)
+            if scope in self.memories:
+                for e in self.memories[scope].entries:
+                    tiers[e.tier.value] += 1
+                    for d in e.domains:
+                        domains[d] += 1
+                    if e.category == "insight":
+                        insight_count += 1
+
+        lines.append("")
+        lines.append(f"Total: {total_entries} entries ({total_size / 1024:.1f} KB)")
+        lines.append("")
+
+        if tiers:
+            lines.append("Tier Distribution:")
+            for tier_name in ["working", "short_term", "long_term", "archival"]:
+                count = tiers.get(tier_name, 0)
+                bar = "#" * (count // max(1, total_entries // 20))
+                lines.append(f"  {tier_name:<12} {count:>4} {bar}")
             lines.append("")
-        
+
+        if domains:
+            lines.append("Domain Distribution:")
+            for domain, count in domains.most_common(6):
+                lines.append(f"  {domain:<15} {count:>3}")
+            lines.append("")
+
+        if insight_count:
+            lines.append(f"Curator Insights: {insight_count} synthesized")
+
         return "\n".join(lines)
 
     def clear_scope(self, scope: MemoryScope) -> None:

minicode/memory_pipeline.py

@@ -106,6 +106,16 @@ def initialize(
             try:
                 from minicode.vector_memory import VectorMemoryStore
                 self._vector_store = VectorMemoryStore()
+                if self._vector_store.enabled and self._memory:
+                    # Index existing memories
+                    all_entries = []
+                    from minicode.memory import MemoryScope
+                    for scope in MemoryScope:
+                        if scope in self._memory.memories:
+                            all_entries.extend(self._memory.memories[scope].entries)
+                    if all_entries:
+                        indexed = self._vector_store.index_entries(all_entries)
+                        logger.info("VectorMemoryStore: indexed %d existing entries", indexed)
             except Exception:
                 pass
 
@@ -158,6 +168,18 @@ def read(
             task_description, active_domains, max_results,
         )
 
+        # 2b. Parallel vector search + RRF fusion (F1)
+        if self._vector_store and self._vector_store.enabled:
+            try:
+                vec_results = self._vector_store.search(
+                    task_description, top_k=max_results,
+                )
+                if vec_results:
+                    from minicode.vector_memory import merge_bm25_vector
+                    entries = merge_bm25_vector(entries, vec_results)
+            except Exception:
+                pass
+
         # 3. Score entries with value function (T1)
         if self._reranker and self._reranker.enabled and len(entries) > 3:
             try:
@@ -286,6 +308,33 @@ def write(
 
         return None
 
+    # ── FEEDBACK: Close the quality loop (F2) ────────────────────────
+
+    def feedback(
+        self,
+        task_success: bool,
+        injected_memory_ids: list[str] | None = None,
+    ) -> None:
+        """Task outcome → memory utility. Closes the outermost learning loop.
+
+        Success → boost injected memories (positive reinforcement).
+        Failure → gentle decay (they may have misled the agent).
+        """
+        if not self._memory or not injected_memory_ids:
+            return
+
+        from minicode.memory import MemoryScope
+        for scope in MemoryScope:
+            if scope not in self._memory.memories:
+                continue
+            for entry in self._memory.memories[scope].entries:
+                if entry.id in injected_memory_ids:
+                    if task_success:
+                        entry.usage_count += 2
+                    else:
+                        entry.usage_count = max(0, entry.usage_count - 1)
+                    entry.last_accessed = time.time()
+
     # ── MAINTAIN: Background optimization ───────────────────────────
 
     def maintain(self, force: bool = False) -> dict[str, Any] | None: