dsh-plugin-xujie-memory 0.6.0 → 0.7.0

package/python/xujie_memory/management.py

@@ -0,0 +1,203 @@
+"""Token-protected data plane for the DSH owner-only, in-app memory panel.
+
+The Host authenticates its owner using the DSH Gateway. The browser never gets
+the kernel token. Explicit scope ids come from catalog(), never guessed user ids.
+Source traces stay immutable: edits atomically replace evidence with a new trace.
+"""
+from __future__ import annotations
+
+import json
+import uuid
+
+from .memory import Memory
+from .profile import ProfileStore
+
+
+class ManagementError(ValueError):
+    def __init__(self, code: str):
+        self.code = code
+        super().__init__(code)
+
+
+class Management:
+    def __init__(self, service):
+        self.service = service
+        self.engine = service.engine
+        self.memory = Memory(self.engine)
+
+    def scope(self, scope_id):
+        row = self.engine._conn().execute(
+            "SELECT * FROM scopes WHERE scope_id=?", (scope_id,)
+        ).fetchone()
+        if row is None:
+            raise ManagementError("scope_not_found")
+        return dict(row)
+
+    def catalog(self):
+        rows = self.engine._conn().execute(
+            "SELECT s.scope_id,s.agent_id,COUNT(t.trace_id) AS traces FROM scopes s"
+            " LEFT JOIN traces t ON s.scope_id=t.scope_id AND t.erased_at IS NULL"
+            " GROUP BY s.scope_id ORDER BY s.agent_id,s.scope_id"
+        ).fetchall()
+        return {"ok": True, "scope_mode": self.service.scope_mode,
+                "scopes": [dict(r) for r in rows]}
+
+    def detail(self, scope_id, trace_id):
+        self.scope(scope_id)
+        row = self.engine.get_trace(trace_id)
+        if row is None or row["scope_id"] != scope_id or row["erased_at"]:
+            raise ManagementError("trace_not_found")
+        weights = self.memory.lifecycle.batch_priority([trace_id]).get(trace_id, {})
+        return {"ok": True, "trace": {
+            "id": trace_id, "trace_id": trace_id, "scope_id": scope_id,
+            "content": row["content"], "content_hash": row["content_hash"],
+            "recorded_at": row["recorded_at"], "source_kind": row["source_kind"],
+            "importance": weights.get("base", 1), "anchor": bool(weights.get("anchor")),
+            "priority": weights.get("priority", 0),
+        }}
+
+    def snapshot(self, scope_id, limit=250):
+        self.scope(scope_id)
+        conn = self.engine._conn()
+        limit = max(1, min(500, int(limit)))
+        # A short read transaction prevents mixed snapshots during concurrent edits.
+        with self.engine._tx():
+            rows = conn.execute(
+                "SELECT trace_id,content,content_hash,recorded_at FROM traces"
+                " WHERE scope_id=? AND erased_at IS NULL"
+                " ORDER BY recorded_at DESC,trace_id LIMIT ?", (scope_id, limit)
+            ).fetchall()
+            weights = self.memory.lifecycle.batch_priority([r["trace_id"] for r in rows])
+            nodes, edges = [], []
+            visible = {r["trace_id"] for r in rows}
+            for i, r in enumerate(rows):
+                w = weights.get(r["trace_id"], {})
+                node = {"id": r["trace_id"], "trace_id": r["trace_id"],
+                        "layer": "episodic", "kind": "trace", "content": r["content"],
+                        "content_hash": r["content_hash"], "recorded_at": r["recorded_at"],
+                        "importance": w.get("base", 1), "anchor": bool(w.get("anchor")),
+                        "priority": w.get("priority", 0), "editable": True}
+                nodes.append(node)
+                if node["anchor"]:
+                    aid = "anchor:" + r["trace_id"]
+                    nodes.append({**node, "id": aid, "layer": "semantic", "kind": "anchor"})
+                    edges.append({"source": r["trace_id"], "target": aid,
+                                  "kind": "anchor_projection"})
+                if i < 8:
+                    wid = "working:" + r["trace_id"]
+                    nodes.append({**node, "id": wid, "layer": "working", "kind": "recent"})
+                    edges.append({"source": r["trace_id"], "target": wid,
+                                  "kind": "working_projection"})
+            states = conn.execute(
+                "SELECT state_key,value_json,status,evaluated_as_of FROM states"
+                " WHERE scope_id=? AND status IN ('known','stale','disputed')"
+                " ORDER BY evaluated_as_of DESC,state_key LIMIT ?", (scope_id, limit)
+            ).fetchall()
+            for r in states:
+                evidence = conn.execute(
+                    "SELECT DISTINCT v.trace_id FROM event_evidence v"
+                    " JOIN events e ON e.event_id=v.event_id"
+                    " JOIN traces t ON t.trace_id=v.trace_id"
+                    " WHERE e.state_key=? AND e.void=0 AND t.erased_at IS NULL"
+                    " ORDER BY v.trace_id", (r["state_key"],),
+                ).fetchall()
+                parts = r["state_key"].split("|")
+                label = " · ".join(parts[1:4])
+                nodes.append({"id": r["state_key"], "layer": "semantic", "kind": "state",
+                              "content": label + "： " + (r["value_json"] or "未知"),
+                              "status": r["status"], "editable": False,
+                              "evidence": [e["trace_id"] for e in evidence]})
+                for e in evidence:
+                    if e["trace_id"] in visible:
+                        edges.append({"source": e["trace_id"], "target": r["state_key"],
+                                      "kind": "evidence"})
+            summaries = conn.execute(
+                "SELECT summary_id,text,input_refs_json,created_at FROM summaries"
+                " WHERE scope_id=? AND lifecycle_state='active' AND text<>''"
+                " ORDER BY created_at DESC,summary_id LIMIT 60", (scope_id,),
+            ).fetchall()
+            for r in summaries:
+                try:
+                    refs = json.loads(r["input_refs_json"])
+                except (TypeError, ValueError):
+                    continue
+                nodes.append({"id": r["summary_id"], "layer": "episodic", "kind": "summary",
+                              "content": r["text"], "editable": False,
+                              "recorded_at": r["created_at"], "evidence": refs})
+                for ref in refs:
+                    if ref in visible:
+                        edges.append({"source": ref, "target": r["summary_id"],
+                                      "kind": "summary_input"})
+            pending = conn.execute(
+                "SELECT request_id,kind,detail_json FROM clarifications"
+                " WHERE scope_id=? AND status='open' ORDER BY created_at DESC LIMIT 50",
+                (scope_id,),
+            ).fetchall()
+            for r in pending:
+                nodes.append({"id": r["request_id"], "layer": "working",
+                              "kind": "clarification", "editable": False,
+                              "content": r["kind"] + "：" + (r["detail_json"] or "")})
+            cards = []
+            store = ProfileStore(self.engine)
+            for row in store.profiles(scope_id):
+                cards.append(store.card(scope_id, row["account_id"], limit=50))
+            stats = self.memory.stats(scope_id)
+        return {"ok": True, "scope_id": scope_id, "scope_mode": self.service.scope_mode,
+                "nodes": nodes, "edges": edges, "cards": cards, "stats": stats,
+                "truncated": stats["traces"] > len(rows),
+                "limit": limit, "render_links_are_not_semantic_inference": True}
+
+    def search(self, scope_id, query, limit=30):
+        self.scope(scope_id)
+        return {"ok": True, "hits": self.memory.search(scope_id, query, limit=limit, candidates=None)}
+
+    def edit(self, scope_id, trace_id, content, expected_hash):
+        self.scope(scope_id)
+        content = content.strip()
+        if not content or len(content) > 2000:
+            raise ManagementError("invalid_content_length")
+        with self.engine._tx():
+            trace = self.detail(scope_id, trace_id)["trace"]
+            if not expected_hash or trace["content_hash"] != expected_hash:
+                raise ManagementError("version_conflict")
+            if trace["content"] == content:
+                return {"ok": True, "changed": False, "trace": trace}
+            original = self.engine.get_trace(trace_id)
+            actor = original["actor_id"]
+            occurred_at = original.get("source_time") or original["recorded_at"]
+            self.memory.forget(scope_id, trace_id)
+            # A saved edit is an explicit user correction, not a fabricated
+            # conversational turn. Do not run profile-watching/auto-replies.
+            result = self.service.orchestrator.ingest.ingest(
+                scope_id, "edit:" + trace_id + ":" + uuid.uuid4().hex,
+                actor, "user_statement", content,
+                context={"peer_id": "assistant", "effective_at": occurred_at}, confirmed=True,
+                pattern_escalation=False,
+            )
+            self.engine._conn().execute(
+                "UPDATE traces SET source_time=?,source_time_precision=? WHERE trace_id=?",
+                (occurred_at, original.get("source_time_precision"), result.trace_id),
+            )
+            self.memory.mark(scope_id, result.trace_id, trace["importance"])
+            if trace["anchor"]:
+                self.memory.lifecycle.set_anchor(result.trace_id, True)
+            store = ProfileStore(self.engine)
+            for row in store.profiles(scope_id):
+                store.derive_from_memory(scope_id, row["account_id"])
+            self.engine._conn().execute(
+                "INSERT INTO memory_edits(edit_id,scope_id,old_trace_id,new_trace_id,edited_at)"
+                " VALUES (?,?,?,?,?)",
+                (uuid.uuid4().hex, scope_id, trace_id, result.trace_id, self.engine.now()),
+            )
+            saved = self.detail(scope_id, result.trace_id)["trace"]
+        return {"ok": True, "changed": True, "replaced_trace_id": trace_id, "trace": saved,
+                "pending": len(result.clarifications)}
+
+    def forget(self, scope_id, trace_id, expected_hash):
+        self.scope(scope_id)
+        with self.engine._tx():
+            trace = self.detail(scope_id, trace_id)["trace"]
+            if not expected_hash or trace["content_hash"] != expected_hash:
+                raise ManagementError("version_conflict")
+            result = self.memory.forget(scope_id, trace_id)
+        return {"ok": True, **result}

package/python/xujie_memory/memory.py

@@ -80,18 +80,21 @@ class FuzzySearch:
         self.engine = engine
 
     def search(self, scope_id: str, query: str, *, limit: int = 5,
-               candidates: int = 800) -> list[dict[str, Any]]:
+               candidates: int | None = 800) -> list[dict[str, Any]]:
         query = (query or "").strip()
         if not query:
             return []
-        rows = self.engine._conn().execute(
-            "SELECT trace_id, content, recorded_at FROM traces"
+        sql = (
+            "SELECT trace_id, content, content_hash, recorded_at FROM traces"
             " WHERE scope_id=? AND erased_at IS NULL"
-            " ORDER BY recorded_at DESC LIMIT ?",
-            (scope_id, max(1, int(candidates))),
-        ).fetchall()
-        # v0.52：查询只预处理一次；内容的二元组按文本缓存（进程内 LRU）。
-        # 每轮 800 条候选，旧版每条都重新规范化查询，单轮约 20ms。
+            " ORDER BY recorded_at DESC"
+        )
+        params = (scope_id,)
+        if candidates is not None:
+            sql += " LIMIT ?"
+            params += (max(1, int(candidates)),)
+        rows = self.engine._conn().execute(sql, params)
+        # 自动召回保持候选上限，管理界面可显式搜索全部有效原话。
         q = _normalize(query)
         if not q:
             return []
@@ -124,6 +127,7 @@ class FuzzySearch:
             out.append({
                 "trace_id": row["trace_id"],
                 "content": row["content"],
+                "content_hash": row["content_hash"],
                 "score": round(float(score), 4),
                 "priority": w.get("priority"),
                 "anchor": bool(w.get("anchor")),
@@ -228,17 +232,18 @@ class Memory:
         trace = self.engine.get_trace(trace_id)
         if trace is None or trace.get("scope_id") != scope_id:
             raise ValueError("trace_not_found")
-        already_erased = bool(trace.get("erased_at"))
-        result = {"state_keys": []} if already_erased else self.engine.erase_trace(trace_id)
-
-        # 状态重算后重新对账画像，避免已删除的事实继续出现在提示词中。
-        from .profile import ProfileStore
-        profiles = ProfileStore(self.engine)
-        accounts = self.engine._conn().execute(
-            "SELECT account_id FROM person_profiles WHERE scope_id=?", (scope_id,)
-        ).fetchall()
-        for account in accounts:
-            profiles.derive_from_memory(scope_id, account["account_id"])
+        # One outer transaction covers evidence, summaries AND the person card.
+        # Nested Engine transactions use savepoints.
+        with self.engine._tx():
+            already_erased = bool(trace.get("erased_at"))
+            result = {"state_keys": []} if already_erased else self.engine.erase_trace(trace_id)
+            from .profile import ProfileStore
+            profiles = ProfileStore(self.engine)
+            accounts = self.engine._conn().execute(
+                "SELECT account_id FROM person_profiles WHERE scope_id=?", (scope_id,)
+            ).fetchall()
+            for account in accounts:
+                profiles.derive_from_memory(scope_id, account["account_id"])
         return {"trace_id": trace_id, "erased": True, "already_erased": already_erased,
                 "state_keys": result["state_keys"]}
 
@@ -273,5 +278,6 @@ class Memory:
         }
 
     # ------------------------------------------------------------ 搜索
-    def search(self, scope_id: str, query: str, *, limit: int = 5) -> list[dict]:
-        return self.fuzzy.search(scope_id, query, limit=limit)
+    def search(self, scope_id: str, query: str, *, limit: int = 5,
+               candidates: int | None = 800) -> list[dict]:
+        return self.fuzzy.search(scope_id, query, limit=limit, candidates=candidates)

package/python/xujie_memory/privacy.py

@@ -0,0 +1,105 @@
+"""Removal of active projections that depend on explicitly erased evidence.
+
+This is logical application erasure, not forensic disk erasure: SQLite WAL,
+external exports/backups and the DSH conversation log are outside this API.
+Audit identifiers, timestamps and hashes are retained, not replacement facts.
+"""
+from __future__ import annotations
+
+import json
+
+
+def repair_legacy(engine, profiles) -> None:
+    """Once-only sweep for projections left by 0.6's incomplete forgetting."""
+    with engine._tx() as conn:
+        if conn.execute(
+            "SELECT 1 FROM memory_maintenance WHERE name='privacy_repair_070'"
+        ).fetchone():
+            return
+        scopes = set()
+        for row in conn.execute(
+            "SELECT trace_id,scope_id FROM traces WHERE erased_at IS NOT NULL"
+        ).fetchall():
+            keys = [r[0] for r in conn.execute(
+                "SELECT DISTINCT e.state_key FROM events e JOIN event_evidence v"
+                " ON e.event_id=v.event_id WHERE v.trace_id=?", (row["trace_id"],)
+            ).fetchall()]
+            purge_derived(engine, conn, row["trace_id"], keys)
+            scopes.add(row["scope_id"])
+        for scope in scopes:
+            for profile in profiles.profiles(scope):
+                profiles.derive_from_memory(scope, profile["account_id"])
+        conn.execute(
+            "INSERT INTO memory_maintenance(name,completed_at) VALUES (?,?)",
+            ("privacy_repair_070", engine.now()),
+        )
+
+
+def purge_derived(engine, conn, trace_id: str, state_keys: list[str]) -> None:
+    trace = conn.execute(
+        "SELECT scope_id FROM traces WHERE trace_id=?", (trace_id,)
+    ).fetchone()
+    if trace is None:
+        return
+    scope = trace["scope_id"]
+    # Merged summaries retain the original trace ids in input_refs_json too.
+    # Clear content, not merely the active flag; otherwise it survives in detail.
+    for row in conn.execute(
+        "SELECT summary_id,input_refs_json FROM summaries WHERE scope_id=?", (scope,)
+    ).fetchall():
+        try:
+            refs = json.loads(row["input_refs_json"])
+        except (TypeError, ValueError):
+            # An unreadable dependency cannot safely remain model-visible.
+            refs = [trace_id]
+        if trace_id in refs:
+            conn.execute(
+                "UPDATE summaries SET text='',lifecycle_state='archived',"
+                "coverage_json='{}',omissions_json='[]' WHERE summary_id=?",
+                (row["summary_id"],),
+            )
+    conn.execute(
+        "UPDATE clarifications SET status='dismissed',detail_json='{}'"
+        " WHERE scope_id=? AND EXISTS ("
+        " SELECT 1 FROM json_each(clarifications.interpretation_ids_json) j"
+        " JOIN interpretations i ON i.interpretation_id=j.value"
+        " WHERE i.trace_id=?)", (scope, trace_id),
+    )
+    conn.execute(
+        "UPDATE encodings SET payload_json='{}' WHERE trace_id=?", (trace_id,)
+    )
+    conn.execute(
+        "UPDATE interpretations SET slots_json='{}',signals_json='{}' WHERE trace_id=?",
+        (trace_id,),
+    )
+    conn.execute(
+        "UPDATE events SET payload_json='{}' WHERE void=1 AND event_id IN"
+        " (SELECT event_id FROM event_evidence WHERE trace_id=?)", (trace_id,),
+    )
+    conn.execute(
+        "UPDATE person_tags SET value='',status='expired' WHERE scope_id=?"
+        " AND evidence_trace_id=?", (scope, trace_id),
+    )
+    conn.execute(
+        "UPDATE profile_alerts SET signals_json='{}',status='dismissed',resolved_at=?"
+        " WHERE scope_id=? AND evidence_trace_id=?", (engine.now(), scope, trace_id),
+    )
+    for table in ("emotion_events", "relationship_events"):
+        conn.execute(
+            f"DELETE FROM {table} WHERE scope_id=? AND evidence_trace_id=?",
+            (scope, trace_id),
+        )
+    conn.execute(
+        "DELETE FROM grievances WHERE scope_id=? AND evidence_trace_id=?",
+        (scope, trace_id),
+    )
+    conn.execute(
+        "UPDATE lifecycle SET anchor=0,level='archived'"
+        " WHERE scope_id=? AND ref_type='trace' AND ref_id=?", (scope, trace_id),
+    )
+    for key in state_keys:
+        conn.execute("DELETE FROM state_snapshots WHERE state_key=?", (key,))
+        conn.execute(
+            "UPDATE states SET last_known_json=NULL WHERE state_key=?"
+            " AND status NOT IN ('known','stale')", (key,),
+        )