From 159bf5a63dd2e570b91260094dd56f40c22d2abd Mon Sep 17 00:00:00 2001 From: Codex Local Date: Thu, 30 Jul 2026 05:34:25 +0800 Subject: [PATCH] feat(c5): add provenance ledger and bridge gates --- _conf_schema.json | 12 + core/bridge.py | 94 ++++++- core/provenance.py | 530 +++++++++++++++++++++++++++++++++++ core/provenance_store.py | 280 ++++++++++++++++++ core/service.py | 229 ++++++++++++++- tests/test_c5_bridge_gate.py | 129 +++++++++ tests/test_c5_provenance.py | 140 +++++++++ 7 files changed, 1408 insertions(+), 6 deletions(-) create mode 100644 core/provenance.py create mode 100644 core/provenance_store.py create mode 100644 tests/test_c5_bridge_gate.py create mode 100644 tests/test_c5_provenance.py diff --git a/_conf_schema.json b/_conf_schema.json index 3b6d999..1cefac7 100644 --- a/_conf_schema.json +++ b/_conf_schema.json @@ -667,6 +667,18 @@ "type": "bool", "default": true }, + "enable_p5_b1_recall_gate": { + "description": "启用 P5-B1 召回闸门", + "hint": "默认关闭。开启后普通记忆注入和主动 recall 需要陪伴侧当前请求的一次性 attestation;无效时返回明确 degraded。", + "type": "bool", + "default": false + }, + "enable_p5_b1_bridge_gate": { + "description": "启用 P5-B1 Bridge 闸门", + "hint": "默认关闭。开启后 Bridge 搜索、上下文和序列化入口需要一次性 attestation;不会删除原版娱乐写入。", + "type": "bool", + "default": false + }, "schedule_fast_context_enabled": { "description": "启用日程快速上下文", "hint": "让陪伴插件读取日程连续性时使用本地只读候选,不调用 Embedding 或 Rerank;关闭后回退完整检索。", diff --git a/core/bridge.py b/core/bridge.py index c4f6772..69a7692 100644 --- a/core/bridge.py +++ b/core/bridge.py @@ -393,8 +393,16 @@ class MemoryCompanionBridge: *, session_context: SessionContext | dict[str, Any] | None = None, top_k: int | None = None, + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, ) -> list[dict[str, Any]]: - return await self._plugin.bridge_search(query, session_context=session_context, top_k=top_k) + return await self._plugin.bridge_search( + query, + session_context=session_context, + top_k=top_k, + p5_attestation=p5_attestation, + p5_attestation_consumer=p5_attestation_consumer, + ) async def compose_injection( self, @@ -405,6 +413,8 @@ class MemoryCompanionBridge: max_chars: int | None = None, companion_bot_mood: str = "", companion_bot_energy: float = 0.0, + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, ) -> str: return await self._plugin.bridge_compose_injection( query, @@ -413,6 +423,8 @@ class MemoryCompanionBridge: max_chars=max_chars, companion_bot_mood=companion_bot_mood, companion_bot_energy=companion_bot_energy, + p5_attestation=p5_attestation, + p5_attestation_consumer=p5_attestation_consumer, ) async def compose_context( @@ -425,6 +437,8 @@ class MemoryCompanionBridge: companion_bot_mood: str = "", companion_bot_energy: float = 0.0, retrieval_profile: str = "", + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, ) -> str: return await self._plugin.bridge_compose_context( query=query, @@ -434,13 +448,74 @@ class MemoryCompanionBridge: companion_bot_mood=companion_bot_mood, companion_bot_energy=companion_bot_energy, retrieval_profile=retrieval_profile, + p5_attestation=p5_attestation, + p5_attestation_consumer=p5_attestation_consumer, ) async def remember(self, *, event: Any, content: str, note_type: str = "memory") -> dict[str, Any]: return await self._plugin.tool_remember(event, content, note_type=note_type) - async def recall(self, *, event: Any, query: str, top_k: int = 5) -> dict[str, Any]: - return await self._plugin.tool_recall(event, query, top_k=top_k) + async def recall( + self, + *, + event: Any, + query: str, + top_k: int = 5, + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, + ) -> dict[str, Any]: + return await self._plugin.tool_recall( + event, + query, + top_k=top_k, + p5_attestation=p5_attestation, + p5_attestation_consumer=p5_attestation_consumer, + ) + + def p5_capability_status(self) -> dict[str, Any]: + getter = getattr(self._plugin, "p5_capability_status", None) + if not callable(getter): + return {"state": "degraded", "error_code": "p5_status_unavailable"} + try: + result = getter() + except Exception: + return {"state": "degraded", "error_code": "p5_status_exception"} + return dict(result) if isinstance(result, dict) else {"state": "degraded", "error_code": "p5_status_invalid"} + + def provenance_snapshot(self) -> dict[str, Any]: + getter = getattr(self._plugin, "provenance_snapshot", None) + if not callable(getter): + return {"records": {}, "operation_count": 0, "state": "degraded"} + result = getter() + return dict(result) if isinstance(result, dict) else {"records": {}, "operation_count": 0, "state": "degraded"} + + def provenance_preview(self, candidates: list[dict[str, Any]], *, operation_ref_hash: str) -> dict[str, Any]: + getter = getattr(self._plugin, "provenance_preview", None) + if not callable(getter): + return {"mode": "preview", "readonly": True, "write_count": 0, "error_codes": ["unavailable"]} + result = getter(candidates, operation_ref_hash=operation_ref_hash) + return dict(result) if isinstance(result, dict) else {"mode": "preview", "readonly": True, "write_count": 0, "error_codes": ["invalid_result"]} + + async def provenance_apply(self, operation: dict[str, Any]) -> dict[str, Any]: + getter = getattr(self._plugin, "provenance_apply", None) + if not callable(getter): + return {"ok": False, "state": "degraded", "error_code": "unavailable"} + result = await getter(operation) + return dict(result) if isinstance(result, dict) else {"ok": False, "state": "degraded", "error_code": "invalid_result"} + + async def provenance_backup(self) -> dict[str, Any]: + getter = getattr(self._plugin, "provenance_backup", None) + if not callable(getter): + return {"ok": False, "state": "degraded", "error_code": "unavailable"} + result = await getter() + return dict(result) if isinstance(result, dict) else {"ok": False, "state": "degraded", "error_code": "invalid_result"} + + async def provenance_rollback(self, operation: dict[str, Any]) -> dict[str, Any]: + getter = getattr(self._plugin, "provenance_rollback", None) + if not callable(getter): + return {"ok": False, "state": "degraded", "error_code": "unavailable"} + result = await getter(operation) + return dict(result) if isinstance(result, dict) else {"ok": False, "state": "degraded", "error_code": "invalid_result"} async def create_note(self, *, event: Any, title: str, content: str = "") -> dict[str, Any]: return await self._plugin.tool_note_create(event, title, content) @@ -574,6 +649,12 @@ class MemoryCompanionBridge: result["capability_schema_version"] = bot_personal_contract.BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION result["payload_schema_version"] = bot_personal_contract.BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION result["capability_state"] = "available" + p5_status = getattr(self._plugin, "p5_capability_status", None) + if callable(p5_status): + try: + result["p5"] = dict(p5_status() or {}) + except Exception: + result["p5"] = {"state": "degraded", "error_code": "p5_status_exception"} self._capability_cache.mark_available(c4_snapshot) result.setdefault("warnings", []) return result @@ -634,6 +715,12 @@ class MemoryCompanionBridge: "consume_context_projection", "read_bot_profile", "read_profile", + "p5_capability_status", + "provenance_snapshot", + "provenance_preview", + "provenance_apply", + "provenance_backup", + "provenance_rollback", "probe_capability_snapshot", "probe_bot_personal_memory_capabilities", ], @@ -697,6 +784,7 @@ class MemoryCompanionBridge: bot_personal_contract, "BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION", "" ) result["capability_state"] = "degraded" + result["p5"] = {"state": "degraded", "error_code": reason} return result def get_token_usage_summary(self) -> dict[str, Any]: diff --git a/core/provenance.py b/core/provenance.py new file mode 100644 index 0000000..fc0eb92 --- /dev/null +++ b/core/provenance.py @@ -0,0 +1,530 @@ +"""Pure chat-side provenance contract and in-memory migration projection. + +The module accepts metadata only. It never reads or stores prompt text, +conversation content, media, credentials, paths, or arbitrary source prose, +and it performs no I/O. A later SQLite adapter may use the plans and CAS +results, but this module deliberately has no knowledge of that adapter. +""" + +from __future__ import annotations + +from collections.abc import Iterable, Mapping +from copy import deepcopy +from dataclasses import asdict, is_dataclass +import hashlib +import json +import re +from typing import Any + + +PROVENANCE_CONTRACT_NAME = "ops.p5.provenance.v1" +PROVENANCE_CONTRACT_VERSION = "1.0" +P3_CONTRACT_NAME = "ops.context_orchestration.v1" +P3_CONTRACT_VERSION = "1.0" +P3_CONTRACT_FINGERPRINT = "3bb7a12af05bb4d9a47cef9f31e78752cec512b90b1d50ae49feef54470974f8" +COMPANION_ATTESTATION_ISSUER = "private_companion" +ATTESTATION_SCHEMA_VERSION = "ops.p5.attestation.v1" + +TRUST_LEVELS = ("T0", "T1", "T2", "T3", "T4") +PROVENANCE_STATES = ("observed", "legacy_unresolved", "owner_recovered", "invalid") +SOURCE_KINDS = ( + "policy_config", "verified_authorization", "current_user_intent", + "forwarded_text", "quoted_text", "vision_summary", "tool_output", + "web_extract", "memory_recall", "derived_summary", "legacy_memory", "unknown", +) +FIREWALL_STATUSES = ( + "allowed", "sanitized", "blocked", "rejected", "quarantined", "unavailable", "unknown", +) +DISPOSITIONS = ("allow", "shadow_quarantine", "deny_high_risk") +HASH_FORMAT = "sha256_hex_lower" + +RECORD_FIELDS = ( + "contract_name", "contract_version", "contract_fingerprint", "memory_id", + "source_kind", "source_trust", "firewall_status", "source_event_ref_hash", + "authority_attestation_ref_hash", "provenance_state", "migration_operation_ref", + "recovery_operation_ref", "record_revision", +) +OPERATION_FIELDS = ( + "contract_name", "contract_version", "contract_fingerprint", "operation_kind", + "operation_ref_hash", "memory_id", "expected_revision", "before_record_digest", + "after_record_digest", "before_record", "after_record", +) + +_SOURCE_KIND_SET = frozenset(SOURCE_KINDS) +_TRUST_SET = frozenset(TRUST_LEVELS) +_FIREWALL_SET = frozenset(FIREWALL_STATUSES) +_DISPOSITION_SET = frozenset(DISPOSITIONS) +_SINKS = frozenset({ + "prompt_forward_quote", "prompt_vision_summary", "memory_recall", + "bridge_serialization", "tool_retrieval", "external_export", "cross_user_read", +}) +_MEMORY_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$") +_SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$") +_TOKEN_RE = re.compile(r"^[a-z][a-z0-9_]{0,63}$") +_FORBIDDEN_RAW_FIELDS = frozenset({ + "body", "content", "text", "message", "prompt", "conversation", "media", + "raw_id", "source_id", "source_event_id", "event_id", "attestation_id", + "authority_attestation_id", "request_id", "session_id", "credential", + "credentials", "password", "secret", "token", "path", "absolute_path", "url", +}) +_SNAPSHOT_FIELDS = frozenset({ + "schema_version", "contract_name", "contract_version", "contract_fingerprint", + "issuer", "issuer_epoch", "p3_contract_name", "p3_contract_version", + "p3_contract_fingerprint", "source_kind", "source_trust", "trust", "firewall_status", + "source_event_ref_hash", "source_hash", "authority_attestation_ref_hash", + "attestation_ref_hash", "disposition", "reason_codes", "request_hash", "session_hash", + "derived_hash", "derived_from_ref_hash", "provenance_state", "sink", +}) + + +def _canonical_json(value: Any) -> str: + return json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(",", ":")) + + +def _digest(value: Mapping[str, Any]) -> str: + return hashlib.sha256(_canonical_json(value).encode("utf-8")).hexdigest() + + +def contract_descriptor() -> dict[str, Any]: + """Return a fresh, closed, JSON-safe descriptor.""" + + return { + "contract_name": PROVENANCE_CONTRACT_NAME, + "contract_version": PROVENANCE_CONTRACT_VERSION, + "record_fields": list(RECORD_FIELDS), + "provenance_states": list(PROVENANCE_STATES), + "trust_levels": list(TRUST_LEVELS), + "source_kinds": list(SOURCE_KINDS), + "firewall_statuses": list(FIREWALL_STATUSES), + "dispositions": list(DISPOSITIONS), + "hash_format": HASH_FORMAT, + "attestation_issuer": COMPANION_ATTESTATION_ISSUER, + "p3_contract_name": P3_CONTRACT_NAME, + "p3_contract_version": P3_CONTRACT_VERSION, + } + + +def contract_fingerprint() -> str: + """Return the canonical descriptor SHA-256 fingerprint.""" + + return _digest(contract_descriptor()) + + +provenance_contract_descriptor = contract_descriptor +provenance_contract_fingerprint = contract_fingerprint + + +def _safe_memory_id(value: Any) -> str: + return value if isinstance(value, str) and _MEMORY_ID_RE.fullmatch(value) else "" + + +def _safe_hash(value: Any) -> str: + return value if isinstance(value, str) and _SHA256_RE.fullmatch(value) and value == value.lower() else "" + + +def _normalize_hash(value: Any) -> str: + if not isinstance(value, str): + return "" + raw = value[7:] if value.startswith("sha256:") else value + return raw.lower() if _SHA256_RE.fullmatch(raw) else "" + + +def _safe_revision(value: Any) -> int | None: + return value if isinstance(value, int) and not isinstance(value, bool) and value >= 0 else None + + +def _known(value: Any, allowed: frozenset[str] | tuple[str, ...]) -> bool: + return isinstance(value, str) and value in allowed + + +def _forbidden(value: Mapping[str, Any]) -> bool: + return any(key in value for key in _FORBIDDEN_RAW_FIELDS) + + +def _error_result(*codes: str) -> dict[str, Any]: + return {"ok": False, "error_codes": sorted(set(codes))} + + +def _blank_record(memory_id: Any = "", *, revision: int = 0, state: str = "invalid") -> dict[str, Any]: + return { + "contract_name": PROVENANCE_CONTRACT_NAME, + "contract_version": PROVENANCE_CONTRACT_VERSION, + "contract_fingerprint": contract_fingerprint(), + "memory_id": _safe_memory_id(memory_id), + "source_kind": "unknown", + "source_trust": "T4", + "firewall_status": "unknown", + "source_event_ref_hash": "", + "authority_attestation_ref_hash": "", + "provenance_state": state, + "migration_operation_ref": "", + "recovery_operation_ref": "", + "record_revision": revision if _safe_revision(revision) is not None else 0, + } + + +def validate_provenance_record(record: Mapping[str, Any] | None) -> dict[str, Any]: + """Return static validation errors or a deep-copied safe record. + + Invalid input values are never returned, so a caller can safely serialize + the result without leaking hostile identifiers or source prose. + """ + + if not isinstance(record, Mapping): + return _error_result("record_not_mapping") + errors: list[str] = [] + if _forbidden(record): + errors.append("forbidden_raw_field") + if set(record) != set(RECORD_FIELDS): + errors.append("record_fields_mismatch") + if record.get("contract_name") != PROVENANCE_CONTRACT_NAME: + errors.append("contract_name_mismatch") + if record.get("contract_version") != PROVENANCE_CONTRACT_VERSION: + errors.append("contract_version_mismatch") + if record.get("contract_fingerprint") != contract_fingerprint(): + errors.append("contract_fingerprint_mismatch") + if not _safe_memory_id(record.get("memory_id")): + errors.append("memory_id_invalid") + if not _known(record.get("source_kind"), _SOURCE_KIND_SET): + errors.append("source_kind_invalid") + if not _known(record.get("source_trust"), _TRUST_SET): + errors.append("source_trust_invalid") + if not _known(record.get("firewall_status"), _FIREWALL_SET): + errors.append("firewall_status_invalid") + if not _known(record.get("provenance_state"), PROVENANCE_STATES): + errors.append("provenance_state_invalid") + if _safe_revision(record.get("record_revision")) is None: + errors.append("record_revision_invalid") + + source = record.get("source_event_ref_hash") + authority = record.get("authority_attestation_ref_hash") + source_hash = _safe_hash(source) + authority_hash = _safe_hash(authority) + if source != "" and not source_hash: + errors.append("source_event_ref_hash_invalid") + if authority != "" and not authority_hash: + errors.append("authority_attestation_ref_hash_invalid") + migration = record.get("migration_operation_ref") + recovery = record.get("recovery_operation_ref") + if migration != "" and not _safe_hash(migration): + errors.append("migration_operation_ref_invalid") + if recovery != "" and not _safe_hash(recovery): + errors.append("recovery_operation_ref_invalid") + + state = record.get("provenance_state") + if state == "legacy_unresolved": + if (record.get("source_kind"), record.get("source_trust"), record.get("firewall_status")) != ("unknown", "T4", "unknown"): + errors.append("legacy_defaults_required") + if source != "" or authority != "": + errors.append("legacy_hashes_forbidden") + elif state in {"observed", "owner_recovered"}: + if record.get("source_kind") == "unknown": + errors.append("observed_source_kind_required") + if not source_hash or not authority_hash: + errors.append("attestation_hashes_required") + if source_hash and source_hash == authority_hash: + errors.append("attestation_hashes_conflict") + if state == "owner_recovered" and not _safe_hash(recovery): + errors.append("recovery_operation_ref_required") + elif state == "invalid" and (source_hash or authority_hash): + errors.append("invalid_hashes_forbidden") + if errors: + return _error_result(*errors) + return {"ok": True, "record": deepcopy(dict(record))} + + +def legacy_unresolved(memory_id: str, *, record_revision: int = 0) -> dict[str, Any]: + """Represent a historical record without guessing its provenance.""" + + result = _blank_record(memory_id, revision=record_revision, state="legacy_unresolved") + return result if result["memory_id"] and validate_provenance_record(result)["ok"] else _blank_record(state="invalid") + + +def _snapshot_mapping(snapshot: Any) -> Mapping[str, Any] | None: + if isinstance(snapshot, Mapping): + return snapshot + if is_dataclass(snapshot): + value = asdict(snapshot) + return value if isinstance(value, Mapping) else None + return None + + +def _paired_hash(snapshot: Mapping[str, Any], *keys: str) -> tuple[str, str]: + values = [_normalize_hash(snapshot[key]) for key in keys if key in snapshot] + if not values: + return "missing", "" + if not all(values): + return "invalid", "" + return ("present", values[0]) if len(set(values)) == 1 else ("conflict", "") + + +def _paired_label(snapshot: Mapping[str, Any], allowed: frozenset[str], *keys: str) -> tuple[str, str]: + values = [snapshot[key] for key in keys if key in snapshot] + if not values: + return "missing", "" + if not all(_known(value, allowed) for value in values): + return "invalid", "" + return ("present", values[0]) if len(set(values)) == 1 else ("conflict", "") + + +def _snapshot_safe(snapshot: Mapping[str, Any]) -> bool: + if set(snapshot) - _SNAPSHOT_FIELDS or _forbidden(snapshot): + return False + if not _known(snapshot.get("disposition"), _DISPOSITION_SET): + return False + codes = snapshot.get("reason_codes", ()) + if not isinstance(codes, (list, tuple)) or len(codes) > 16: + return False + if not all(isinstance(code, str) and _TOKEN_RE.fullmatch(code) for code in codes): + return False + for key in ("request_hash", "session_hash", "issuer_epoch"): + if not _normalize_hash(snapshot.get(key)): + return False + derived = [snapshot[key] for key in ("derived_hash", "derived_from_ref_hash") if key in snapshot and snapshot[key] != ""] + if derived and (any(not _normalize_hash(value) for value in derived) or len({_normalize_hash(value) for value in derived}) != 1): + return False + return snapshot.get("provenance_state") == "observed" and _known(snapshot.get("sink"), _SINKS) + + +def observed_from_companion_snapshot(memory_id: str, snapshot: Any, *, record_revision: int = 0) -> dict[str, Any]: + """Create ``observed`` only from a complete, attested Companion snapshot.""" + + safe_id = _safe_memory_id(memory_id) + revision = _safe_revision(record_revision) + data = _snapshot_mapping(snapshot) + if not safe_id or revision is None or data is None or not _snapshot_safe(data): + return _blank_record(safe_id, revision=revision or 0) + expected = { + "schema_version": ATTESTATION_SCHEMA_VERSION, + "issuer": COMPANION_ATTESTATION_ISSUER, + "contract_name": PROVENANCE_CONTRACT_NAME, + "contract_version": PROVENANCE_CONTRACT_VERSION, + "contract_fingerprint": contract_fingerprint(), + "p3_contract_name": P3_CONTRACT_NAME, + "p3_contract_version": P3_CONTRACT_VERSION, + "p3_contract_fingerprint": P3_CONTRACT_FINGERPRINT, + } + if any(data.get(key) != value for key, value in expected.items()): + return _blank_record(safe_id, revision=revision) + source_status, source_hash = _paired_hash(data, "source_event_ref_hash", "source_hash") + authority_status, authority_hash = _paired_hash(data, "authority_attestation_ref_hash", "attestation_ref_hash") + trust_status, trust = _paired_label(data, _TRUST_SET, "source_trust", "trust") + source_kind = data.get("source_kind") + firewall = data.get("firewall_status") + if ( + source_status != "present" or authority_status != "present" or trust_status != "present" + or source_hash == authority_hash or not _known(source_kind, _SOURCE_KIND_SET - {"unknown"}) + or not _known(firewall, _FIREWALL_SET) + ): + return _blank_record(safe_id, revision=revision) + record = _blank_record(safe_id, revision=revision, state="observed") + record.update({ + "source_kind": source_kind, "source_trust": trust, "firewall_status": firewall, + "source_event_ref_hash": source_hash, "authority_attestation_ref_hash": authority_hash, + }) + return record if validate_provenance_record(record)["ok"] else _blank_record(safe_id, revision=revision) + + +def provenance_record_digest(record: Mapping[str, Any] | None) -> str: + checked = validate_provenance_record(record) + return _digest(checked["record"]) if checked["ok"] else "" + + +def _record_or_none(value: Any) -> dict[str, Any] | None: + checked = validate_provenance_record(value if isinstance(value, Mapping) else None) + return deepcopy(checked["record"]) if checked["ok"] else None + + +def _operation(*, operation_kind: str, operation_ref_hash: str, before_record: Mapping[str, Any] | None, after_record: Mapping[str, Any]) -> dict[str, Any] | None: + before = _record_or_none(before_record) + after = _record_or_none(after_record) + reference = _safe_hash(operation_ref_hash) + if operation_kind not in {"migration", "recovery"} or not reference or after is None: + return None + if before is not None and before["memory_id"] != after["memory_id"]: + return None + expected = before["record_revision"] if before is not None else after["record_revision"] - 1 + if expected < 0 or after["record_revision"] != expected + 1: + return None + operation = { + "contract_name": PROVENANCE_CONTRACT_NAME, "contract_version": PROVENANCE_CONTRACT_VERSION, + "contract_fingerprint": contract_fingerprint(), "operation_kind": operation_kind, + "operation_ref_hash": reference, "memory_id": after["memory_id"], "expected_revision": expected, + "before_record_digest": _digest(before) if before is not None else "", + "after_record_digest": _digest(after), "before_record": before, "after_record": after, + } + return operation if validate_operation(operation)["ok"] else None + + +def validate_operation(operation: Mapping[str, Any] | None) -> dict[str, Any]: + if not isinstance(operation, Mapping): + return _error_result("operation_not_mapping") + errors: list[str] = [] + if _forbidden(operation): + errors.append("forbidden_raw_field") + if set(operation) != set(OPERATION_FIELDS): + errors.append("operation_fields_mismatch") + if operation.get("contract_name") != PROVENANCE_CONTRACT_NAME: + errors.append("contract_name_mismatch") + if operation.get("contract_version") != PROVENANCE_CONTRACT_VERSION: + errors.append("contract_version_mismatch") + if operation.get("contract_fingerprint") != contract_fingerprint(): + errors.append("contract_fingerprint_mismatch") + if operation.get("operation_kind") not in {"migration", "recovery"}: + errors.append("operation_kind_invalid") + if not _safe_hash(operation.get("operation_ref_hash")): + errors.append("operation_ref_invalid") + if not _safe_memory_id(operation.get("memory_id")): + errors.append("memory_id_invalid") + expected = _safe_revision(operation.get("expected_revision")) + if expected is None: + errors.append("expected_revision_invalid") + before = _record_or_none(operation.get("before_record")) + after = _record_or_none(operation.get("after_record")) + if operation.get("before_record") is not None and before is None: + errors.append("before_record_invalid") + if after is None: + errors.append("after_record_invalid") + if before is None and operation.get("before_record_digest") != "": + errors.append("before_digest_required_empty") + if before is not None and operation.get("before_record_digest") != _digest(before): + errors.append("before_digest_mismatch") + if after is not None and operation.get("after_record_digest") != _digest(after): + errors.append("after_digest_mismatch") + if after is not None: + if operation.get("memory_id") != after["memory_id"]: + errors.append("memory_id_mismatch") + if expected is not None and after["record_revision"] != expected + 1: + errors.append("revision_progression_invalid") + ref_field = "migration_operation_ref" if operation.get("operation_kind") == "migration" else "recovery_operation_ref" + if after.get(ref_field) != operation.get("operation_ref_hash"): + errors.append("operation_ref_not_bound") + if before is not None and after is not None: + if before["memory_id"] != after["memory_id"]: + errors.append("before_after_memory_mismatch") + if expected is not None and before["record_revision"] != expected: + errors.append("before_revision_mismatch") + return _error_result(*errors) if errors else {"ok": True, "operation": deepcopy(dict(operation))} + + +def plan_legacy_migration(records: Iterable[Mapping[str, Any]], *, operation_ref_hash: str) -> dict[str, Any]: + """Return a non-mutating preview for unresolved legacy records.""" + + reference = _safe_hash(operation_ref_hash) + result: dict[str, Any] = { + "mode": "preview", "readonly": True, "write_count": 0, + "operation_ref_hash": reference, "operations": [], "skipped": [], "error_codes": [], + } + if not reference: + result["error_codes"].append("operation_ref_invalid") + return result + if isinstance(records, (str, bytes)) or not isinstance(records, Iterable): + result["error_codes"].append("records_not_iterable") + return result + for candidate in records: + if not isinstance(candidate, Mapping) or _forbidden(candidate): + result["error_codes"].append("candidate_invalid") + continue + existing = _record_or_none(candidate) + if existing is not None: + result["skipped"].append({"memory_id": existing["memory_id"], "reason_code": "already_provenanced"}) + continue + if set(candidate) != {"memory_id", "record_revision"}: + result["error_codes"].append("candidate_fields_mismatch") + continue + memory_id = _safe_memory_id(candidate.get("memory_id")) + revision = _safe_revision(candidate.get("record_revision")) + if not memory_id or revision is None: + result["error_codes"].append("candidate_invalid") + continue + after = legacy_unresolved(memory_id, record_revision=revision + 1) + after["migration_operation_ref"] = reference + operation = _operation(operation_kind="migration", operation_ref_hash=reference, before_record=None, after_record=after) + if operation is None: + result["error_codes"].append("operation_invalid") + else: + result["operations"].append(operation) + result["error_codes"] = sorted(set(result["error_codes"])) + return result + + +def _minimal_current(current: Mapping[str, Any] | None) -> tuple[str, int | None, dict[str, Any] | None, str]: + if not isinstance(current, Mapping) or _forbidden(current): + return "", None, None, "current_invalid" + record = _record_or_none(current) + if record is not None: + return record["memory_id"], record["record_revision"], record, "" + if set(current) != {"memory_id", "record_revision"}: + return "", None, None, "current_fields_mismatch" + return _safe_memory_id(current.get("memory_id")), _safe_revision(current.get("record_revision")), None, "" + + +def apply_planned_operation(current: Mapping[str, Any] | None, operation: Mapping[str, Any] | None) -> dict[str, Any]: + """Apply a plan to an in-memory mapping with exact revision CAS.""" + + checked = validate_operation(operation) + if not checked["ok"]: + return {"ok": False, "mode": "apply", "status": "invalid_operation", "error_codes": checked["error_codes"]} + op = checked["operation"] + memory_id, revision, current_record, error = _minimal_current(current) + if error or not memory_id or revision is None: + return {"ok": False, "mode": "apply", "status": "invalid_current", "error_codes": [error or "current_invalid"]} + if current_record is not None and _digest(current_record) == op["after_record_digest"]: + return {"ok": True, "mode": "apply", "status": "idempotent", "record": deepcopy(op["after_record"]), "changed": False} + if memory_id != op["memory_id"] or revision != op["expected_revision"]: + return {"ok": False, "mode": "apply", "status": "revision_conflict", "error_codes": ["revision_or_memory_mismatch"]} + before = op["before_record"] + if before is None: + if current_record is not None: + return {"ok": False, "mode": "apply", "status": "revision_conflict", "error_codes": ["unexpected_existing_provenance"]} + elif current_record is None or _digest(current_record) != op["before_record_digest"]: + return {"ok": False, "mode": "apply", "status": "revision_conflict", "error_codes": ["before_record_mismatch"]} + return {"ok": True, "mode": "apply", "status": "applied", "record": deepcopy(op["after_record"]), "changed": True} + + +def rollback_planned_operation(current: Mapping[str, Any] | None, operation: Mapping[str, Any] | None) -> dict[str, Any]: + """Rollback only when the current record still matches the plan's CAS.""" + + checked = validate_operation(operation) + if not checked["ok"]: + return {"ok": False, "mode": "rollback", "status": "invalid_operation", "error_codes": checked["error_codes"]} + op = checked["operation"] + memory_id, revision, current_record, error = _minimal_current(current) + if error or current_record is None or revision is None: + return {"ok": False, "mode": "rollback", "status": "invalid_current", "error_codes": [error or "current_invalid"]} + if memory_id != op["memory_id"] or revision != op["after_record"]["record_revision"] or _digest(current_record) != op["after_record_digest"]: + return {"ok": False, "mode": "rollback", "status": "revision_conflict", "error_codes": ["concurrent_update_protected"]} + before = op["before_record"] + return {"ok": True, "mode": "rollback", "status": "rolled_back", "record": deepcopy(before) if before is not None else None, "removed": before is None, "changed": True} + + +def plan_owner_recovery(current: Mapping[str, Any], snapshot: Mapping[str, Any], *, recovery_operation_ref_hash: str) -> dict[str, Any]: + """Plan attested owner recovery for one legacy-unresolved record.""" + + existing = _record_or_none(current) + reference = _safe_hash(recovery_operation_ref_hash) + if existing is None or existing["provenance_state"] != "legacy_unresolved" or not reference: + return {"ok": False, "mode": "preview", "error_codes": ["recovery_precondition_failed"]} + after = observed_from_companion_snapshot(existing["memory_id"], snapshot, record_revision=existing["record_revision"] + 1) + if after["provenance_state"] != "observed": + return {"ok": False, "mode": "preview", "error_codes": ["companion_snapshot_invalid"]} + after["provenance_state"] = "owner_recovered" + after["migration_operation_ref"] = existing["migration_operation_ref"] + after["recovery_operation_ref"] = reference + operation = _operation(operation_kind="recovery", operation_ref_hash=reference, before_record=existing, after_record=after) + if operation is None: + return {"ok": False, "mode": "preview", "error_codes": ["operation_invalid"]} + return {"ok": True, "mode": "preview", "readonly": True, "write_count": 0, "operation": operation} + + +__all__ = [ + "ATTESTATION_SCHEMA_VERSION", "COMPANION_ATTESTATION_ISSUER", "DISPOSITIONS", + "FIREWALL_STATUSES", "HASH_FORMAT", "OPERATION_FIELDS", "P3_CONTRACT_FINGERPRINT", + "P3_CONTRACT_NAME", "P3_CONTRACT_VERSION", "PROVENANCE_CONTRACT_NAME", + "PROVENANCE_CONTRACT_VERSION", "PROVENANCE_STATES", "RECORD_FIELDS", "SOURCE_KINDS", + "TRUST_LEVELS", "apply_planned_operation", "contract_descriptor", "contract_fingerprint", + "legacy_unresolved", "observed_from_companion_snapshot", "plan_legacy_migration", + "plan_owner_recovery", "provenance_contract_descriptor", "provenance_contract_fingerprint", + "provenance_record_digest", "rollback_planned_operation", "validate_operation", + "validate_provenance_record", +] diff --git a/core/provenance_store.py b/core/provenance_store.py new file mode 100644 index 0000000..dd03abb --- /dev/null +++ b/core/provenance_store.py @@ -0,0 +1,280 @@ +"""Small append-only provenance ledger for the chat-side memory plugin. + +The ledger stores only validated provenance records and migration audit +metadata. It never accepts prompt text, conversation content, media, +credentials, or arbitrary source prose. Writes are atomic and every mutation +creates a backup before the current projection changes. +""" + +from __future__ import annotations + +from copy import deepcopy +import json +from pathlib import Path +import shutil +import threading +import time +from typing import Any, Mapping + +from .provenance import ( + apply_planned_operation, + plan_legacy_migration, + provenance_record_digest, + rollback_planned_operation, + validate_operation, + validate_provenance_record, +) + + +LEDGER_SCHEMA_VERSION = "ops.p5.provenance.ledger.v1" + + +class ProvenanceLedger: + """Persist validated provenance projections with CAS-protected writes.""" + + def __init__(self, path: Path): + self.path = Path(path) + self._lock = threading.RLock() + + def _empty(self) -> dict[str, Any]: + return {"schema_version": LEDGER_SCHEMA_VERSION, "records": {}, "operations": [], "observations": []} + + def _load_locked(self) -> dict[str, Any]: + if not self.path.is_file(): + return self._empty() + try: + raw = json.loads(self.path.read_text(encoding="utf-8")) + except (OSError, ValueError, TypeError): + return self._empty() + if not isinstance(raw, dict) or raw.get("schema_version") != LEDGER_SCHEMA_VERSION: + return self._empty() + records: dict[str, dict[str, Any]] = {} + raw_records = raw.get("records") + if isinstance(raw_records, dict): + for memory_id, value in raw_records.items(): + checked = validate_provenance_record(value if isinstance(value, Mapping) else None) + if checked.get("ok") and checked.get("record", {}).get("memory_id") == memory_id: + records[memory_id] = deepcopy(checked["record"]) + operations: list[dict[str, Any]] = [] + raw_operations = raw.get("operations") + if isinstance(raw_operations, list): + for value in raw_operations: + checked = validate_operation(value if isinstance(value, Mapping) else None) + if checked.get("ok"): + operations.append(deepcopy(checked["operation"])) + elif isinstance(value, dict) and value.get("kind") == "rollback": + safe = self._safe_rollback_audit(value) + if safe is not None: + operations.append(safe) + observations: list[dict[str, Any]] = [] + raw_observations = raw.get("observations") + if isinstance(raw_observations, list): + for value in raw_observations: + safe = self._safe_observation(value) + if safe is not None: + observations.append(safe) + return { + "schema_version": LEDGER_SCHEMA_VERSION, + "records": records, + "operations": operations, + "observations": observations, + } + + @staticmethod + def _safe_observation(value: Any) -> dict[str, Any] | None: + if not isinstance(value, Mapping) or set(value) != { + "memory_id", "record_digest", "record_revision", "source_event_ref_hash", + "authority_attestation_ref_hash", "provenance_state", + }: + return None + if ( + not isinstance(value.get("memory_id"), str) + or not value["memory_id"] + or not isinstance(value.get("record_digest"), str) + or len(value["record_digest"]) != 64 + or not isinstance(value.get("source_event_ref_hash"), str) + or len(value["source_event_ref_hash"]) != 64 + or not isinstance(value.get("authority_attestation_ref_hash"), str) + or len(value["authority_attestation_ref_hash"]) != 64 + or not isinstance(value.get("record_revision"), int) + or value["record_revision"] < 1 + or value.get("provenance_state") not in {"observed", "owner_recovered"} + ): + return None + return { + "memory_id": value["memory_id"][:120], + "record_digest": value["record_digest"].lower(), + "record_revision": value["record_revision"], + "source_event_ref_hash": value["source_event_ref_hash"].lower(), + "authority_attestation_ref_hash": value["authority_attestation_ref_hash"].lower(), + "provenance_state": value["provenance_state"], + } + + @staticmethod + def _safe_rollback_audit(value: Mapping[str, Any]) -> dict[str, Any] | None: + memory_id = value.get("memory_id") + before_digest = value.get("before_digest") + after_digest = value.get("after_digest") + from_revision = value.get("from_revision") + to_revision = value.get("to_revision") + if ( + not isinstance(memory_id, str) + or not memory_id + or not isinstance(before_digest, str) + or len(before_digest) != 64 + or not isinstance(after_digest, str) + or len(after_digest) != 64 + or not isinstance(from_revision, int) + or from_revision < 0 + or not isinstance(to_revision, int) + or to_revision < 0 + ): + return None + return { + "kind": "rollback", + "memory_id": memory_id[:120], + "before_digest": before_digest.lower(), + "after_digest": after_digest.lower(), + "from_revision": from_revision, + "to_revision": to_revision, + } + + def _write_locked(self, document: Mapping[str, Any]) -> None: + self.path.parent.mkdir(parents=True, exist_ok=True) + temporary = self.path.with_name(f".{self.path.name}.{threading.get_ident()}.tmp") + temporary.write_text( + json.dumps(document, ensure_ascii=True, sort_keys=True, separators=(",", ":")), + encoding="utf-8", + ) + temporary.replace(self.path) + + def _backup_locked(self) -> bool: + if not self.path.is_file(): + return False + backup = self.path.with_name(f"{self.path.name}.backup.{time.time_ns()}") + try: + shutil.copy2(self.path, backup) + return True + except OSError: + return False + + @staticmethod + def _minimal_current(memory_id: str, record: Mapping[str, Any] | None) -> dict[str, Any]: + if isinstance(record, Mapping): + return deepcopy(dict(record)) + return {"memory_id": memory_id, "record_revision": 0} + + def snapshot(self) -> dict[str, Any]: + with self._lock: + document = self._load_locked() + return { + "schema_version": LEDGER_SCHEMA_VERSION, + "records": deepcopy(document["records"]), + "operation_count": len(document["operations"]), + "observation_count": len(document["observations"]), + "path_present": self.path.is_file(), + } + + def preview_legacy(self, candidates: list[Mapping[str, Any]], *, operation_ref_hash: str) -> dict[str, Any]: + return plan_legacy_migration(candidates, operation_ref_hash=operation_ref_hash) + + def backup(self) -> dict[str, Any]: + with self._lock: + if not self.path.is_file(): + return {"ok": True, "state": "nothing_to_backup", "created": False} + created = self._backup_locked() + return {"ok": created, "state": "backed_up" if created else "degraded", "created": created} + + def apply(self, operation: Mapping[str, Any]) -> dict[str, Any]: + checked = validate_operation(operation) + if not checked.get("ok"): + return {"ok": False, "state": "invalid", "error_codes": checked.get("error_codes", [])} + op = checked["operation"] + with self._lock: + document = self._load_locked() + current = self._minimal_current(op["memory_id"], document["records"].get(op["memory_id"])) + result = apply_planned_operation(current, op) + if not result.get("ok") or not result.get("changed"): + return {**result, "backup_created": False} + backup_created = self._backup_locked() + document["records"][op["memory_id"]] = deepcopy(result["record"]) + document["operations"].append(deepcopy(op)) + self._write_locked(document) + return {**result, "backup_created": backup_created, "operation_count": len(document["operations"])} + + def rollback(self, operation: Mapping[str, Any]) -> dict[str, Any]: + checked = validate_operation(operation) + if not checked.get("ok"): + return {"ok": False, "state": "invalid", "error_codes": checked.get("error_codes", [])} + op = checked["operation"] + with self._lock: + document = self._load_locked() + current = document["records"].get(op["memory_id"]) + result = rollback_planned_operation(current, op) + if not result.get("ok"): + return {**result, "backup_created": False} + backup_created = self._backup_locked() + if result.get("removed"): + document["records"].pop(op["memory_id"], None) + else: + document["records"][op["memory_id"]] = deepcopy(result["record"]) + document["operations"].append( + { + "kind": "rollback", + "memory_id": op["memory_id"], + "before_digest": op["after_record_digest"], + "after_digest": provenance_record_digest(result.get("record")) if result.get("record") else "0" * 64, + "from_revision": op["after_record"]["record_revision"], + "to_revision": result.get("record", {}).get("record_revision", 0) if result.get("record") else 0, + } + ) + self._write_locked(document) + return {**result, "backup_created": backup_created, "operation_count": len(document["operations"])} + + def record_observed(self, memory_ids: list[str], snapshot: Any) -> dict[str, Any]: + """Append observed metadata for selected memories without raw payloads.""" + + from .provenance import observed_from_companion_snapshot + + safe_ids = [item for item in memory_ids if isinstance(item, str) and item][:64] + if not safe_ids: + return {"ok": False, "state": "invalid", "error_code": "memory_ids_empty", "written": 0} + with self._lock: + document = self._load_locked() + updates: dict[str, dict[str, Any]] = {} + for memory_id in safe_ids: + current = document["records"].get(memory_id) + revision = int(current.get("record_revision", 0)) if isinstance(current, dict) else 0 + record = observed_from_companion_snapshot(memory_id, snapshot, record_revision=revision + 1) + checked = validate_provenance_record(record) + if not checked.get("ok"): + continue + if isinstance(current, dict) and current == checked["record"]: + continue + updates[memory_id] = deepcopy(checked["record"]) + if not updates: + return {"ok": True, "state": "deduplicated", "written": 0, "backup_created": False} + backup_created = self._backup_locked() + document["records"].update(updates) + for record in updates.values(): + document["observations"].append( + { + "memory_id": record["memory_id"], + "record_digest": provenance_record_digest(record), + "record_revision": record["record_revision"], + "source_event_ref_hash": record["source_event_ref_hash"], + "authority_attestation_ref_hash": record["authority_attestation_ref_hash"], + "provenance_state": record["provenance_state"], + } + ) + self._write_locked(document) + return { + "ok": True, + "state": "written", + "written": len(updates), + "memory_ids": list(updates), + "backup_created": backup_created, + } + + +__all__ = ["LEDGER_SCHEMA_VERSION", "ProvenanceLedger"] diff --git a/core/service.py b/core/service.py index 4c34718..b022fcd 100644 --- a/core/service.py +++ b/core/service.py @@ -11,7 +11,7 @@ import inspect import re from datetime import datetime, timedelta, timezone from pathlib import Path -from typing import Any +from typing import Any, Mapping from zoneinfo import ZoneInfo from .astrbot_compat import ( @@ -51,6 +51,8 @@ from .operations import ( detect_preset, persist_runtime_config, ) +from .provenance import observed_from_companion_snapshot +from .provenance_store import ProvenanceLedger from .qq_history import QQHistoryReader from .reply_chain import ReplyChainResolver from .retrieval import RetrievalEngine @@ -178,6 +180,152 @@ class MemoryCompanionService: self._relationship_phase_state: dict[str, dict[str, Any]] = {} self._RELATIONSHIP_PHASE_FILE = self.data_dir / "memory_companion_relationship_phase.json" self._load_relationship_phase_state() + self.provenance_ledger = ProvenanceLedger(self.data_dir / "provenance_ledger.json") + self._last_p5_gate_status: dict[str, Any] = {"state": "disabled", "enabled": False} + + def _p5_gate_enabled(self, sink: str) -> bool: + key = ( + "private_companion_bridge.enable_p5_b1_recall_gate" + if sink == "memory_recall" + else "private_companion_bridge.enable_p5_b1_bridge_gate" + ) + return self.config.bool(key, False) + + async def _p5_gate( + self, + *, + event: Any = None, + sink: str, + attestation: Any = None, + consumer: Any = None, + ) -> dict[str, Any]: + if not self._p5_gate_enabled(sink): + if attestation is not None and callable(consumer): + try: + consumed = consumer(attestation, sink) + if inspect.isawaitable(consumed): + await consumed + except Exception: + pass + result = {"ok": True, "state": "legacy", "legacy": True, "enabled": False} + self._last_p5_gate_status = result + return result + if attestation is None and event is not None: + issuer = getattr(event, "private_companion_p5_issue_attestation", None) + if callable(issuer): + try: + issued = issuer(sink) + except Exception: + issued = None + if isinstance(issued, tuple) and len(issued) == 2: + attestation, consumer = issued + if attestation is None or not callable(consumer): + result = { + "ok": False, + "state": "degraded", + "enabled": True, + "error_code": "p5_attestation_required", + "warnings": ["legacy_call_not_attested"], + } + self._last_p5_gate_status = result + return result + try: + snapshot = consumer(attestation, sink) + if inspect.isawaitable(snapshot): + snapshot = await snapshot + except Exception: + snapshot = None + snapshot_record = observed_from_companion_snapshot("p5_gate", snapshot) + snapshot_sink = getattr(snapshot, "sink", None) + if snapshot_sink is None and isinstance(snapshot, Mapping): + snapshot_sink = snapshot.get("sink") + if snapshot_record.get("provenance_state") != "observed" or snapshot_sink != sink: + result = { + "ok": False, + "state": "denied", + "enabled": True, + "error_code": "p5_attestation_invalid", + "warnings": ["invalid_or_replayed_attestation"], + } + self._last_p5_gate_status = result + return result + disposition = str(getattr(snapshot, "disposition", "") or "") + trust = str(getattr(snapshot, "source_trust", "") or "") + if isinstance(snapshot, Mapping): + disposition = str(snapshot.get("disposition") or disposition) + trust = str(snapshot.get("source_trust") or snapshot.get("trust") or trust) + if disposition == "deny_high_risk": + state = "denied" + error_code = "p5_high_risk_denied" + allowed = False + elif disposition != "allow" or trust in {"T3", "T4"}: + state = "shadow" + error_code = "p5_source_shadowed" + allowed = False + else: + state = "allowed" + error_code = "" + allowed = True + result = { + "ok": allowed, + "state": state, + "enabled": True, + "snapshot": snapshot, + "error_code": error_code or None, + "warnings": [] if allowed else [error_code], + } + self._last_p5_gate_status = { + key: value for key, value in result.items() if key != "snapshot" + } + return result + + def p5_capability_status(self) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + snapshot = ledger.snapshot() if isinstance(ledger, ProvenanceLedger) else {"operation_count": 0, "observation_count": 0, "path_present": False} + return { + "schema_version": "ops.p5.provenance.v1", + "recall_gate": self._p5_gate_enabled("memory_recall"), + "bridge_gate": self._p5_gate_enabled("bridge_serialization"), + "last_gate_state": str(getattr(self, "_last_p5_gate_status", {}).get("state") or "disabled"), + "provenance_records": len(snapshot.get("records", {})), + "provenance_operations": int(snapshot.get("operation_count", 0) or 0), + "provenance_observations": int(snapshot.get("observation_count", 0) or 0), + "provenance_file_present": bool(snapshot.get("path_present", False)), + } + + async def _p5_record_observed(self, memory_ids: list[str], snapshot: Any) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + if not isinstance(ledger, ProvenanceLedger): + return {"ok": False, "state": "degraded", "error_code": "provenance_ledger_unavailable"} + return await asyncio.to_thread(ledger.record_observed, memory_ids, snapshot) + + def provenance_snapshot(self) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + return ledger.snapshot() if isinstance(ledger, ProvenanceLedger) else {"records": {}, "operation_count": 0} + + def provenance_preview(self, candidates: list[Mapping[str, Any]], *, operation_ref_hash: str) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + if not isinstance(ledger, ProvenanceLedger): + return {"mode": "preview", "readonly": True, "write_count": 0, "error_codes": ["ledger_unavailable"]} + return ledger.preview_legacy(candidates, operation_ref_hash=operation_ref_hash) + + async def provenance_backup(self) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + if not isinstance(ledger, ProvenanceLedger): + return {"ok": False, "state": "degraded", "error_code": "ledger_unavailable"} + return await asyncio.to_thread(ledger.backup) + + async def provenance_apply(self, operation: Mapping[str, Any]) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + if not isinstance(ledger, ProvenanceLedger): + return {"ok": False, "state": "degraded", "error_code": "ledger_unavailable"} + return await asyncio.to_thread(ledger.apply, operation) + + async def provenance_rollback(self, operation: Mapping[str, Any]) -> dict[str, Any]: + ledger = getattr(self, "provenance_ledger", None) + if not isinstance(ledger, ProvenanceLedger): + return {"ok": False, "state": "degraded", "error_code": "ledger_unavailable"} + return await asyncio.to_thread(ledger.rollback, operation) def preview_historical_chat_upload( self, @@ -917,10 +1065,23 @@ class MemoryCompanionService: *, session_context: SessionContext | dict[str, Any] | None = None, top_k: int | None = None, + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, ) -> list[dict[str, Any]]: + gate = await self._p5_gate( + sink="bridge_serialization", + attestation=p5_attestation, + consumer=p5_attestation_consumer, + ) + if not gate.get("ok"): + return [] ctx = self.session_context_from_bridge(session_context) results = await self.search(query, ctx, top_k or self.config.int("memory_injection.top_k", 6)) - return [serialize_memory(item.memory, item.score, item.reason) for item in results] + serialized = [serialize_memory(item.memory, item.score, item.reason) for item in results] + snapshot = gate.get("snapshot") + if snapshot is not None: + await self._p5_record_observed([item.memory.id for item in results], snapshot) + return serialized async def bridge_compose_injection( self, @@ -931,7 +1092,18 @@ class MemoryCompanionService: max_chars: int | None = None, companion_bot_mood: str = "", companion_bot_energy: float = 0.0, + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, + _p5_gate_passed: bool = False, ) -> str: + if not _p5_gate_passed: + gate = await self._p5_gate( + sink="bridge_serialization", + attestation=p5_attestation, + consumer=p5_attestation_consumer, + ) + if not gate.get("ok"): + return "" ctx = self.session_context_from_bridge(session_context) query_text = clean_text(query or ctx.message_text, 1400) if not query_text: @@ -957,7 +1129,16 @@ class MemoryCompanionService: companion_bot_mood: str = "", companion_bot_energy: float = 0.0, retrieval_profile: str = "", + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, ) -> str: + gate = await self._p5_gate( + sink="bridge_serialization", + attestation=p5_attestation, + consumer=p5_attestation_consumer, + ) + if not gate.get("ok"): + return "" profile = clean_text(retrieval_profile, 40).lower() fast_profile_enabled = { "schedule_fast": self.config.bool( @@ -986,6 +1167,7 @@ class MemoryCompanionService: max_chars=max_chars, companion_bot_mood=companion_bot_mood, companion_bot_energy=companion_bot_energy, + _p5_gate_passed=True, ) async def _bridge_compose_schedule_fast_context( @@ -3379,14 +3561,39 @@ class MemoryCompanionService: self._schedule_memory_embedding(memory_id, record) return {"ok": True, "memory_id": memory_id, "review_status": record.review_status} - async def tool_recall(self, event: Any, query: str, top_k: int = 5) -> dict[str, Any]: + async def tool_recall( + self, + event: Any, + query: str, + top_k: int = 5, + *, + p5_attestation: Any = None, + p5_attestation_consumer: Any = None, + ) -> dict[str, Any]: ctx = await self.identity.resolve_event_context(event) query = clean_text(query, 1000) if not query: return {"ok": False, "error": "empty query", "memories": []} + p5_gate = await self._p5_gate( + event=event, + sink="memory_recall", + attestation=p5_attestation, + consumer=p5_attestation_consumer, + ) + if not p5_gate.get("ok"): + return { + "ok": False, + "state": p5_gate.get("state", "degraded"), + "error": p5_gate.get("error_code", "p5_attestation_required"), + "memories": [], + } results = await self.search(query, ctx, max(1, min(10, int(top_k or 5)))) + snapshot = p5_gate.get("snapshot") + if snapshot is not None: + await self._p5_record_observed([item.memory.id for item in results], snapshot) return { "ok": True, + "state": p5_gate.get("state", "legacy"), "memories": [serialize_memory(item.memory, item.score, item.reason) for item in results], } @@ -4519,6 +4726,22 @@ class MemoryCompanionService: if self.config.bool("memory_injection.debug_log_injection_enabled", False): logger.info("[MemoryCompanion] 记忆注入已关闭: session=%s", ctx.session_id) return + p5_gate = await self._p5_gate(event=event, sink="memory_recall") + if not p5_gate.get("ok"): + self._mark_memory_companion_injection_state( + event, + req, + injected=False, + conversation_memory=False, + slot_map={}, + ) + logger.info( + "[MemoryCompanion] P5 召回闸门未放行本轮记忆注入: session=%s state=%s error=%s", + ctx.session_id, + p5_gate.get("state"), + p5_gate.get("error_code"), + ) + return self._sanitize_request_history_for_companion(ctx, req) recent_fact_context = await self._recent_fact_guard_context(ctx) recent_cross_window_context = await self._recent_cross_window_context(ctx) diff --git a/tests/test_c5_bridge_gate.py b/tests/test_c5_bridge_gate.py new file mode 100644 index 0000000..165b0e7 --- /dev/null +++ b/tests/test_c5_bridge_gate.py @@ -0,0 +1,129 @@ +from __future__ import annotations + +import asyncio +from pathlib import Path +import sys +import tempfile +import unittest + +COMPANION_ROOT = Path(__file__).resolve().parents[2] / "astrbot_plugin_private_companion-main" / "astrbot_plugin_private_companion-main" +if str(COMPANION_ROOT) not in sys.path: + sys.path.insert(0, str(COMPANION_ROOT)) + +from p5_attestation import P5AttestationRegistry # noqa: E402 + +from core.config import ConfigView # noqa: E402 +from core.provenance_store import ProvenanceLedger # noqa: E402 +from core.service import MemoryCompanionService # noqa: E402 + + +def run(coro): + return asyncio.run(coro) + + +def make_service(*, bridge_gate: bool = True, recall_gate: bool = True): + service = object.__new__(MemoryCompanionService) + service.config = ConfigView( + { + "private_companion_bridge": { + "enable_p5_b1_bridge_gate": bridge_gate, + "enable_p5_b1_recall_gate": recall_gate, + } + } + ) + service._last_p5_gate_status = {} + return service + + +def mint(registry, *, request, event, p3, source_kind="current_user_intent", trust="T2", disposition="allow", sink="bridge_serialization"): + handle = registry.mint( + request, + event, + p3, + request_hash="a" * 64, + session_hash="b" * 64, + source_kind=source_kind, + source_trust=trust, + firewall_status="allowed", + disposition=disposition, + reason_codes=("evidence_only_nonexecuting",) if disposition == "allow" else ("untrusted_source_shadowed", "p5_nonexecuting"), + source_event_ref_hash="c" * 64, + sinks=(sink,), + ) + return handle, lambda candidate, requested_sink=sink: registry.consume(candidate, request, event, p3, requested_sink) + + +class C5BridgeGateTests(unittest.TestCase): + def test_bridge_gate_accepts_current_user_attestation_and_rejects_replay(self): + service = make_service() + registry = P5AttestationRegistry() + request, event, p3 = object(), object(), object() + handle, consumer = mint(registry, request=request, event=event, p3=p3) + allowed = run(service._p5_gate(sink="bridge_serialization", attestation=handle, consumer=consumer)) + replay = run(service._p5_gate(sink="bridge_serialization", attestation=handle, consumer=consumer)) + self.assertTrue(allowed["ok"]) + self.assertEqual(allowed["state"], "allowed") + self.assertFalse(replay["ok"]) + self.assertEqual(replay["error_code"], "p5_attestation_invalid") + + def test_shadow_source_is_not_allowed_to_expand_recall(self): + service = make_service() + registry = P5AttestationRegistry() + request, event, p3 = object(), object(), object() + handle, consumer = mint( + registry, + request=request, + event=event, + p3=p3, + source_kind="forwarded_text", + trust="T3", + disposition="shadow_quarantine", + ) + result = run(service._p5_gate(sink="bridge_serialization", attestation=handle, consumer=consumer)) + self.assertFalse(result["ok"]) + self.assertEqual(result["state"], "shadow") + + def test_disabled_gate_preserves_legacy_behavior(self): + service = make_service(bridge_gate=False, recall_gate=False) + result = run(service._p5_gate(sink="memory_recall")) + self.assertEqual(result, {"ok": True, "state": "legacy", "legacy": True, "enabled": False}) + + def test_ledger_preview_apply_backup_and_cas_rollback(self): + with tempfile.TemporaryDirectory() as directory: + ledger = ProvenanceLedger(Path(directory) / "provenance_ledger.json") + preview = ledger.preview_legacy( + [{"memory_id": "memory-1", "record_revision": 0}], + operation_ref_hash="d" * 64, + ) + self.assertTrue(preview["readonly"]) + self.assertEqual(preview["write_count"], 0) + operation = preview["operations"][0] + applied = ledger.apply(operation) + self.assertTrue(applied["ok"]) + self.assertEqual(applied["status"], "applied") + self.assertTrue(ledger.backup()["created"]) + self.assertEqual(ledger.snapshot()["records"]["memory-1"]["provenance_state"], "legacy_unresolved") + conflict = ledger.rollback({**operation, "after_record_digest": "e" * 64}) + self.assertFalse(conflict["ok"]) + rolled_back = ledger.rollback(operation) + self.assertTrue(rolled_back["ok"]) + self.assertEqual(rolled_back["status"], "rolled_back") + + def test_dual_plugin_snapshot_is_recorded_without_raw_payload(self): + service = make_service(bridge_gate=True, recall_gate=False) + with tempfile.TemporaryDirectory() as directory: + service.provenance_ledger = ProvenanceLedger(Path(directory) / "provenance_ledger.json") + registry = P5AttestationRegistry() + request, event, p3 = object(), object(), object() + handle, consumer = mint(registry, request=request, event=event, p3=p3) + gate = run(service._p5_gate(sink="bridge_serialization", attestation=handle, consumer=consumer)) + result = run(service._p5_record_observed(["memory-1"], gate["snapshot"])) + snapshot = service.provenance_snapshot() + self.assertTrue(result["ok"]) + self.assertEqual(snapshot["records"]["memory-1"]["provenance_state"], "observed") + self.assertNotIn("content", str(snapshot)) + self.assertNotIn("prompt", str(snapshot)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_c5_provenance.py b/tests/test_c5_provenance.py new file mode 100644 index 0000000..47d26a7 --- /dev/null +++ b/tests/test_c5_provenance.py @@ -0,0 +1,140 @@ +from __future__ import annotations + +import copy +import hashlib +import json +import unittest + +from core.provenance import ( + ATTESTATION_SCHEMA_VERSION, + COMPANION_ATTESTATION_ISSUER, + P3_CONTRACT_FINGERPRINT, + P3_CONTRACT_NAME, + P3_CONTRACT_VERSION, + PROVENANCE_CONTRACT_NAME, + PROVENANCE_CONTRACT_VERSION, + apply_planned_operation, + contract_descriptor, + contract_fingerprint, + legacy_unresolved, + observed_from_companion_snapshot, + plan_legacy_migration, + rollback_planned_operation, + validate_provenance_record, +) + + +def _hash(value: str) -> str: + return hashlib.sha256(value.encode("utf-8")).hexdigest() + + +def _snapshot(**overrides: object) -> dict[str, object]: + value: dict[str, object] = { + "schema_version": ATTESTATION_SCHEMA_VERSION, + "contract_name": PROVENANCE_CONTRACT_NAME, + "contract_version": PROVENANCE_CONTRACT_VERSION, + "contract_fingerprint": contract_fingerprint(), + "issuer": COMPANION_ATTESTATION_ISSUER, + "issuer_epoch": _hash("issuer-epoch"), + "p3_contract_name": P3_CONTRACT_NAME, + "p3_contract_version": P3_CONTRACT_VERSION, + "p3_contract_fingerprint": P3_CONTRACT_FINGERPRINT, + "source_kind": "forwarded_text", + "source_trust": "T3", + "firewall_status": "sanitized", + "disposition": "shadow_quarantine", + "reason_codes": ("p5b_attested",), + "source_event_ref_hash": _hash("source-event"), + "authority_attestation_ref_hash": _hash("authority-attestation"), + "request_hash": _hash("request"), + "session_hash": _hash("session"), + "derived_from_ref_hash": "", + "provenance_state": "observed", + "sink": "memory_recall", + } + value.update(overrides) + return value + + +class C5ProvenanceTests(unittest.TestCase): + def test_descriptor_fingerprint_is_closed_and_stable(self) -> None: + descriptor = contract_descriptor() + canonical = json.dumps(descriptor, ensure_ascii=True, sort_keys=True, separators=(",", ":")) + self.assertEqual(_hash(canonical), contract_fingerprint()) + self.assertEqual(13, len(descriptor["record_fields"])) + json.dumps(descriptor, ensure_ascii=True) + + def test_legacy_unresolved_is_conservative_and_valid(self) -> None: + record = legacy_unresolved("memory-42", record_revision=4) + self.assertEqual("legacy_unresolved", record["provenance_state"]) + self.assertEqual(("unknown", "T4", "unknown"), (record["source_kind"], record["source_trust"], record["firewall_status"])) + self.assertTrue(validate_provenance_record(record)["ok"]) + + def test_valid_snapshot_becomes_observed_and_invalid_snapshot_is_safe(self) -> None: + record = observed_from_companion_snapshot("memory-42", _snapshot(), record_revision=7) + self.assertEqual("observed", record["provenance_state"]) + self.assertTrue(validate_provenance_record(record)["ok"]) + self.assertEqual(_hash("source-event"), record["source_event_ref_hash"]) + + invalid = observed_from_companion_snapshot("memory-42", _snapshot(source_trust="T9")) + self.assertEqual("invalid", invalid["provenance_state"]) + invalid = observed_from_companion_snapshot("memory-42", _snapshot(content="raw prose")) + self.assertEqual("invalid", invalid["provenance_state"]) + + def test_record_and_preview_reject_raw_fields_without_echoing_them(self) -> None: + record = legacy_unresolved("memory-42") + record["content"] = "do not retain this" + result = validate_provenance_record(record) + rendered = json.dumps(result, ensure_ascii=False, sort_keys=True) + self.assertFalse(result["ok"]) + self.assertIn("forbidden_raw_field", result["error_codes"]) + self.assertNotIn("do not retain this", rendered) + + hostile = [{"memory_id": "memory-secret", "record_revision": 0, "prompt": "secret prompt"}] + preview = plan_legacy_migration(hostile, operation_ref_hash=_hash("migration")) + self.assertEqual([], preview["operations"]) + self.assertNotIn("secret prompt", json.dumps(preview, ensure_ascii=False)) + + def test_preview_is_immutable_and_apply_returns_a_new_record(self) -> None: + source = [{"memory_id": "memory-42", "record_revision": 4}] + before = copy.deepcopy(source) + preview = plan_legacy_migration(source, operation_ref_hash=_hash("migration-42")) + self.assertEqual(before, source) + self.assertEqual(("preview", True, 0), (preview["mode"], preview["readonly"], preview["write_count"])) + operation = preview["operations"][0] + applied = apply_planned_operation({"memory_id": "memory-42", "record_revision": 4}, operation) + self.assertEqual((True, "applied", True), (applied["ok"], applied["status"], applied["changed"])) + self.assertIsNot(applied["record"], operation["after_record"]) + + def test_apply_is_idempotent_and_rollback_uses_cas(self) -> None: + operation = plan_legacy_migration( + [{"memory_id": "memory-42", "record_revision": 4}], operation_ref_hash=_hash("migration-42") + )["operations"][0] + applied = apply_planned_operation({"memory_id": "memory-42", "record_revision": 4}, operation) + retry = apply_planned_operation(applied["record"], operation) + self.assertEqual((True, "idempotent", False), (retry["ok"], retry["status"], retry["changed"])) + + concurrent = copy.deepcopy(applied["record"]) + concurrent["record_revision"] += 1 + conflict = rollback_planned_operation(concurrent, operation) + self.assertEqual((False, "revision_conflict"), (conflict["ok"], conflict["status"])) + + rolled_back = rollback_planned_operation(applied["record"], operation) + self.assertEqual((True, "rolled_back", True), (rolled_back["ok"], rolled_back["status"], rolled_back["removed"])) + self.assertIsNone(rolled_back["record"]) + + def test_owner_recovery_is_preview_only_and_requires_attested_snapshot(self) -> None: + legacy = legacy_unresolved("memory-42", record_revision=2) + from core.provenance import plan_owner_recovery + + planned = plan_owner_recovery(legacy, _snapshot(), recovery_operation_ref_hash=_hash("recovery")) + self.assertTrue(planned["ok"]) + self.assertEqual("owner_recovered", planned["operation"]["after_record"]["provenance_state"]) + rejected = plan_owner_recovery( + legacy, _snapshot(p3_contract_fingerprint=_hash("wrong-p3")), recovery_operation_ref_hash=_hash("recovery-2") + ) + self.assertEqual(["companion_snapshot_invalid"], rejected["error_codes"]) + + +if __name__ == "__main__": + unittest.main()