feat(brain): Gedächtnis nach scope trennen (system/personal)

Neues Feld scope=system|personal auf jedem Memory-Punkt. Bootstrap-Export
getrennt: System-Regeln (generisch, teilbar) vs. Persönliches (Name,
Zugangsdaten, Projekte). Import ist scope-sicher — ein System-Import löscht
NICHT die persönlichen pinned Memories. seed_rules + AGENT.md/TOOLING.md →
system, USER.md-Präferenzen → personal. Backfill für Bestand (57 system /
617 personal). Diagnostic: zwei Export-Buttons, scope-Badge (SYS/PRIV) +
Umschalter pro Memory.

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

aria-brain/memory/vector_store.py

@@ -11,6 +11,10 @@ Punkt-Schema (Payload):
     content   — eigentlicher Text (wird embedded)
     pinned    — bool, True = Hot Memory (immer in Prompt)
     source    — import | conversation | manual
+    scope     — system | personal. system = generische Regeln, die JEDER
+                braucht, der das System aufsetzt (Sicherheit, Ehrlichkeit,
+                Skill-Regeln). personal = Stefan-spezifisch (Name, Zugangs-
+                daten, Projekte). Steuert den getrennten Bootstrap-Export.
     tags      — Liste von Strings
     created_at, updated_at — ISO-Strings
     conversation_id — optional, nur fuer type=conversation
@@ -55,6 +59,7 @@ class MemoryPoint:
     pinned: bool = False
     category: str = ""
     source: str = "manual"
+    scope: str = "personal"  # system | personal — steuert Bootstrap-Export
     tags: List[str] = field(default_factory=list)
     created_at: str = ""
     updated_at: str = ""
@@ -74,6 +79,7 @@ class MemoryPoint:
             "pinned": self.pinned,
             "category": self.category,
             "source": self.source,
+            "scope": self.scope,
             "tags": self.tags,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
@@ -94,6 +100,7 @@ class MemoryPoint:
             pinned=payload.get("pinned", False),
             category=payload.get("category", ""),
             source=payload.get("source", "manual"),
+            scope=payload.get("scope", "personal"),
             tags=payload.get("tags", []),
             created_at=payload.get("created_at", ""),
             updated_at=payload.get("updated_at", ""),
@@ -120,14 +127,23 @@ class VectorStore:
                 collection_name=COLLECTION,
                 vectors_config=qm.VectorParams(size=VECTOR_DIM, distance=qm.Distance.COSINE),
             )
-            # Indexe fuer typische Filter-Felder
-            for field_name in ("type", "pinned", "category", "source", "migration_key"):
+        # Indexe fuer typische Filter-Felder — idempotent, laeuft auch auf
+        # einer bestehenden Collection (fuer neu hinzugekommene Felder wie scope).
+        self._ensure_indexes()
+
+    def _ensure_indexes(self):
+        for field_name in ("type", "pinned", "category", "source", "scope", "migration_key"):
+            schema = (qm.PayloadSchemaType.BOOL if field_name == "pinned"
+                      else qm.PayloadSchemaType.KEYWORD)
+            try:
                 self.client.create_payload_index(
                     collection_name=COLLECTION,
                     field_name=field_name,
-                    field_schema=qm.PayloadSchemaType.KEYWORD if field_name != "pinned"
-                    else qm.PayloadSchemaType.BOOL,
+                    field_schema=schema,
                 )
+            except Exception:
+                # Index existiert bereits — kein Problem.
+                pass
 
     # ─── Schreib-Operationen ─────────────────────────────────────────
 
@@ -164,6 +180,38 @@ class VectorStore:
             qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True))
         ]))
 
+    def list_pinned_by_scope(self, scope: str) -> List[MemoryPoint]:
+        """Alle pinned Punkte eines scope (system | personal). Fuer den
+        getrennten Bootstrap-Export."""
+        return self._scroll(filter=qm.Filter(must=[
+            qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True)),
+            qm.FieldCondition(key="scope", match=qm.MatchValue(value=scope)),
+        ]))
+
+    def list_index_titles(self, limit: int = 500) -> List[MemoryPoint]:
+        """Leichtgewichtiger Titel-Index des kalten Gedaechtnisses fuer den
+        System-Prompt: ARIA sieht WAS sie an Nachschlage-Wissen hat (Zugangs-
+        daten, Infrastruktur, Projekte) und holt den Inhalt bei Bedarf via
+        memory_search — statt Stefan nach etwas zu fragen, das schon da ist.
+
+        Bewusst NUR die deliberat gespeicherten Punkte:
+          - nicht pinned (die sind eh schon voll im Prompt),
+          - kein type=conversation (Chat-Mitschnitte),
+          - kein source=distilled (die 100e auto-destillierten Gespraechs-
+            Fakten — die traegt das semantische Auto-Retrieval, sie hier
+            als Titel zu listen wuerde nur Kontext fressen).
+        So bleibt der Index klein (Dutzende statt Hunderte Zeilen)."""
+        return self._scroll(
+            filter=qm.Filter(
+                must_not=[
+                    qm.FieldCondition(key="pinned", match=qm.MatchValue(value=True)),
+                    qm.FieldCondition(key="type", match=qm.MatchValue(value="conversation")),
+                    qm.FieldCondition(key="source", match=qm.MatchValue(value="distilled")),
+                ]
+            ),
+            limit=limit,
+        )
+
     def list_by_type(self, type_: str, limit: int = 100) -> List[MemoryPoint]:
         return self._scroll(
             filter=qm.Filter(must=[