astrbot_plugin_private_comp.../unified_person_contract.py

663 行
28 KiB
Python

# -*- coding: utf-8 -*-
"""Versioned, read-only unified-person contract owned by PrivateCompanion.
This module deliberately has no AstrBot dependency. The memory plugin may only
consume the projections produced here; person creation, linking, and migration
remain in the companion plugin's data domain.
"""
from __future__ import annotations
from copy import deepcopy
from datetime import datetime, timezone
import hashlib
import json
from typing import Any
import unicodedata
import re
CONTRACT_NAME = "ops.unified_person.v1"
CONTRACT_VERSION = "1.0"
CONTRACT_SAMPLE_VERSION = "1.0"
UNIFIED_PERSON_STORE_VERSION = 1
UNIFIED_PERSON_MIGRATION_VERSION = 1
IDENTITY_FIELDS = (
"companion_instance_id",
"bot_account_id",
"adapter_instance_id",
"subject_namespace",
"platform_subject_id",
)
PROJECTION_FIELDS = (
"contract_name",
"contract_version",
"contract_fingerprint",
"projection_revision",
"person_id",
"resolved_identity_key",
"identity_assurance",
"profile_status",
"display_name",
"aliases",
"relation_policy_id",
"relation_label",
"relationship_capabilities",
"owner_mode",
"affinity_score",
"affinity_band",
"warning_stage",
"confinement_state",
"confinement_until",
"release_prompt_pending",
"proactive_private_enabled",
"group_overlay_ref",
"updated_at",
)
IDENTITY_ASSURANCE_VALUES = frozenset({"unverified", "observed", "verified", "explicit_linked"})
PROFILE_STATUS_VALUES = frozenset({"active", "suspended", "quarantined", "deleted"})
OWNER_MODE_VALUES = frozenset({"none", "owner", "not_owner"})
AFFINITY_BAND_VALUES = frozenset({"critical", "guarded", "neutral", "positive"})
WARNING_STAGE_VALUES = frozenset({"none", "warning_1", "warning_2", "confinement"})
CONFINEMENT_STATE_VALUES = frozenset({"none", "active", "released"})
COORDINATION_STATUS_VALUES = frozenset({
"resolved",
"pending_companion",
"contract_mismatch",
"identity_conflict",
"quarantined",
"legacy_unresolved",
})
RELATIONSHIP_CAPABILITIES = frozenset({
"comfort",
"proactive_care",
"joking",
"hugging",
"hand_holding",
"head_pat",
"leaning_close",
"sweet_talk",
"affectionate_address",
"missing_you",
"acting_cute",
"jealousy",
"flirting",
"romantic_expression",
"confession",
"exclusivity",
"public_favoritism",
"nsfw",
})
def _canonical_json(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def _contract_shape() -> dict[str, Any]:
return {
"name": CONTRACT_NAME,
"version": CONTRACT_VERSION,
"sample_version": CONTRACT_SAMPLE_VERSION,
"required_fields": sorted(PROJECTION_FIELDS),
"identity_key_fields": sorted(IDENTITY_FIELDS),
"enums": {
"identity_assurance": sorted(IDENTITY_ASSURANCE_VALUES),
"profile_status": sorted(PROFILE_STATUS_VALUES),
"owner_mode": sorted(OWNER_MODE_VALUES),
"affinity_band": sorted(AFFINITY_BAND_VALUES),
"warning_stage": sorted(WARNING_STAGE_VALUES),
"confinement_state": sorted(CONFINEMENT_STATE_VALUES),
"coordination_status": sorted(COORDINATION_STATUS_VALUES),
"relationship_capabilities": sorted(RELATIONSHIP_CAPABILITIES),
},
}
CONTRACT_FINGERPRINT = hashlib.sha256(_canonical_json(_contract_shape()).encode("utf-8")).hexdigest()
def contract_manifest() -> dict[str, Any]:
"""Return a deterministic manifest suitable for bridge capability checks."""
manifest = _contract_shape()
manifest["contract_fingerprint"] = CONTRACT_FINGERPRINT
return manifest
def _text(value: Any, field: str, *, limit: int = 160) -> str:
if isinstance(value, bool) or not isinstance(value, (str, int)):
raise ValueError(f"{field} must be a scalar string")
text = unicodedata.normalize("NFC", str(value)).strip()
if not text:
raise ValueError(f"{field} is required")
if "\x00" in text or len(text) > limit:
raise ValueError(f"{field} is invalid")
return text
def canonical_identity(identity: dict[str, Any]) -> dict[str, str]:
"""Normalize all five identity dimensions without inferring equivalence."""
if not isinstance(identity, dict):
raise ValueError("identity must be an object")
result = {field: _text(identity.get(field), field) for field in IDENTITY_FIELDS}
result["subject_namespace"] = result["subject_namespace"].lower()
return result
def build_identity_key(identity: dict[str, Any]) -> str:
"""A stable complete identity key. It never falls back to a bare platform ID."""
normalized = _canonical_json(canonical_identity(identity))
digest = hashlib.sha256(normalized.encode("utf-8")).hexdigest()
return f"ops-origin-v1:{digest}"
def person_id_for_identity(identity: dict[str, Any]) -> str:
digest = hashlib.sha256(build_identity_key(identity).encode("utf-8")).hexdigest()
return f"person_{digest[:24]}"
def affinity_band(score: Any) -> str:
numeric = int(score)
if numeric <= -800:
return "critical"
if numeric < 0:
return "guarded"
if numeric == 0:
return "neutral"
return "positive"
def _utc_now() -> str:
return datetime.now(timezone.utc).isoformat(timespec="seconds")
def empty_unified_person_store() -> dict[str, Any]:
return {
"version": UNIFIED_PERSON_STORE_VERSION,
"profiles": {},
"identity_links": {},
"relation_policies": {
"default_friend": {
"relation_policy_id": "default_friend",
"label": "friend",
"sort_order": 100,
"capabilities": [],
"proactive_private_enabled": False,
"active": True,
},
},
"group_overlays": {},
"registry_version": 1,
"audit_events": [],
"operations": {},
"merge_operations": {},
"migration": {"version": 0, "applied_ids": [], "backups": {}},
}
def ensure_unified_person_store(data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
"""Install only empty, forward-compatible containers; never migrate automatically."""
if not isinstance(data, dict):
raise ValueError("store must be an object")
changed = False
root = data.get("unified_person")
if not isinstance(root, dict):
data["unified_person"] = empty_unified_person_store()
return data, True
defaults = empty_unified_person_store()
for key, default in defaults.items():
if key not in root or not isinstance(root.get(key), type(default)):
root[key] = deepcopy(default)
changed = True
try:
current_version = int(root.get("version") or 0)
except (TypeError, ValueError):
current_version = 0
root["version"] = max(current_version, UNIFIED_PERSON_STORE_VERSION)
migration = root["migration"]
for key, default in defaults["migration"].items():
if key not in migration or not isinstance(migration.get(key), type(default)):
migration[key] = deepcopy(default)
changed = True
return data, changed
def _safe_score(value: Any) -> int:
try:
score = int(value)
except (TypeError, ValueError):
score = 0
return max(-1200, min(1200, score))
def _enum(value: Any, allowed: frozenset[str], default: str) -> str:
text = str(value or "").strip()
return text if text in allowed else default
def _positive_int(value: Any, default: int = 1) -> int:
try:
result = int(value)
except (TypeError, ValueError):
return default
return max(1, result)
def _safe_aliases(value: Any) -> list[str]:
if not isinstance(value, list):
return []
result: list[str] = []
for item in value:
try:
text = _text(item, "alias", limit=120)
except ValueError:
continue
if text not in result:
result.append(text)
return result
def _projection_aliases(value: Any) -> list[str] | None:
if not isinstance(value, list):
return None
if any(not isinstance(item, str) or not item.strip() or "\x00" in item or len(item) > 120 for item in value):
return None
return list(value)
def _relation_policy(root: dict[str, Any], relation_policy_id: str) -> dict[str, Any]:
policies = root.get("relation_policies") if isinstance(root.get("relation_policies"), dict) else {}
policy = policies.get(relation_policy_id)
if isinstance(policy, dict):
return policy
return policies.get("default_friend") if isinstance(policies.get("default_friend"), dict) else {}
def build_person_projection(store: dict[str, Any], person_id: str) -> dict[str, Any] | None:
"""Build the sole bridge payload. This function is intentionally read-only."""
root = store.get("unified_person") if isinstance(store, dict) else None
if not isinstance(root, dict):
return None
profiles = root.get("profiles") if isinstance(root.get("profiles"), dict) else {}
profile = profiles.get(str(person_id or ""))
if not isinstance(profile, dict):
return None
policy_id = profile.get("relation_policy_id")
if not isinstance(policy_id, str) or not policy_id:
return None
policy = _relation_policy(root, policy_id)
score = _safe_score(profile.get("affinity_score"))
capabilities = [item for item in _safe_aliases(policy.get("capabilities")) if item in RELATIONSHIP_CAPABILITIES]
identity_key = profile.get("resolved_identity_key")
if not isinstance(identity_key, str):
return None
aliases = _projection_aliases(profile.get("aliases"))
if aliases is None:
return None
person_value = profile.get("person_id")
display_name = profile.get("display_name")
relation_label = policy.get("label")
updated_at = profile.get("updated_at")
if not all(isinstance(item, str) for item in (person_value, display_name, relation_label, updated_at)):
return None
links = root.get("identity_links") if isinstance(root.get("identity_links"), dict) else {}
link = links.get(identity_key) if isinstance(links.get(identity_key), dict) else {}
assurance = _enum(
profile.get("identity_assurance") or link.get("identity_assurance"),
IDENTITY_ASSURANCE_VALUES,
"unverified",
)
projection = {
"contract_name": CONTRACT_NAME,
"contract_version": CONTRACT_VERSION,
"contract_fingerprint": CONTRACT_FINGERPRINT,
"projection_revision": _positive_int(profile.get("projection_revision")),
"person_id": person_value,
"resolved_identity_key": identity_key,
"identity_assurance": assurance,
"profile_status": _enum(profile.get("profile_status"), PROFILE_STATUS_VALUES, "active"),
"display_name": display_name,
"aliases": aliases,
"relation_policy_id": policy_id,
"relation_label": relation_label,
"relationship_capabilities": capabilities,
"owner_mode": "owner" if profile.get("owner_mode") == "owner" else "not_owner",
"affinity_score": score,
"affinity_band": affinity_band(score),
"warning_stage": _enum(profile.get("warning_stage"), WARNING_STAGE_VALUES, "none"),
"confinement_state": _enum(profile.get("confinement_state"), CONFINEMENT_STATE_VALUES, "none"),
"confinement_until": str(profile.get("confinement_until") or ""),
"release_prompt_pending": bool(profile.get("release_prompt_pending")),
"proactive_private_enabled": bool(profile.get("proactive_private_enabled", policy.get("proactive_private_enabled", False))),
"group_overlay_ref": str(profile.get("group_overlay_ref") or ""),
"updated_at": updated_at,
}
# A corrupted persisted record must not escape as an invalid bridge payload.
return projection if not validate_projection(projection) else None
def validate_projection(projection: dict[str, Any]) -> list[str]:
"""Validate an incoming projection without silently coercing contract fields."""
if not isinstance(projection, dict):
return ["projection must be an object"]
errors = [f"missing {field}" for field in PROJECTION_FIELDS if field not in projection]
if errors:
return errors
if projection["contract_name"] != CONTRACT_NAME:
errors.append("contract_name mismatch")
if projection["contract_version"] != CONTRACT_VERSION:
errors.append("contract_version mismatch")
if projection["contract_fingerprint"] != CONTRACT_FINGERPRINT:
errors.append("contract_fingerprint mismatch")
if not isinstance(projection["projection_revision"], int) or projection["projection_revision"] < 1:
errors.append("projection_revision invalid")
for field in ("person_id", "display_name", "relation_policy_id", "relation_label"):
if not isinstance(projection[field], str) or not projection[field] or "\x00" in projection[field] or len(projection[field]) > 160:
errors.append(f"{field} invalid")
identity_key = projection["resolved_identity_key"]
if not isinstance(identity_key, str) or not re.fullmatch(r"ops-origin-v1:[0-9a-f]{64}", identity_key):
errors.append("resolved_identity_key invalid")
if not isinstance(projection["updated_at"], str) or not projection["updated_at"] or "\x00" in projection["updated_at"] or len(projection["updated_at"]) > 80:
errors.append("updated_at invalid")
if not isinstance(projection["aliases"], list) or any(
not isinstance(item, str) or not item.strip() or "\x00" in item or len(item) > 120
for item in projection["aliases"]
):
errors.append("aliases invalid")
if not isinstance(projection["relationship_capabilities"], list) or not set(projection["relationship_capabilities"]).issubset(RELATIONSHIP_CAPABILITIES):
errors.append("relationship_capabilities invalid")
enum_checks = {
"identity_assurance": IDENTITY_ASSURANCE_VALUES,
"profile_status": PROFILE_STATUS_VALUES,
"owner_mode": OWNER_MODE_VALUES,
"affinity_band": AFFINITY_BAND_VALUES,
"warning_stage": WARNING_STAGE_VALUES,
"confinement_state": CONFINEMENT_STATE_VALUES,
}
for field, allowed in enum_checks.items():
if projection[field] not in allowed:
errors.append(f"{field} invalid")
if not isinstance(projection["affinity_score"], int) or not -1200 <= projection["affinity_score"] <= 1200:
errors.append("affinity_score invalid")
elif projection["affinity_band"] != affinity_band(projection["affinity_score"]):
errors.append("affinity_band inconsistent")
for field in ("release_prompt_pending", "proactive_private_enabled"):
if not isinstance(projection[field], bool):
errors.append(f"{field} invalid")
for field in ("confinement_until", "group_overlay_ref"):
if not isinstance(projection[field], str):
errors.append(f"{field} invalid")
return errors
def resolve_identity(store: dict[str, Any], identity: dict[str, Any]) -> dict[str, Any]:
"""Resolve an identity only. No bridge consumer can create a person through it."""
try:
identity_key = build_identity_key(identity)
except ValueError:
return {"state": "quarantined", "identity_key": "", "person_id": "", "error_code": "invalid_identity"}
root = store.get("unified_person") if isinstance(store, dict) else None
links = root.get("identity_links") if isinstance(root, dict) and isinstance(root.get("identity_links"), dict) else {}
link = links.get(identity_key)
if not isinstance(link, dict):
return {"state": "pending_companion", "identity_key": identity_key, "person_id": ""}
person_id = str(link.get("person_id") or "")
projection = build_person_projection(store, person_id)
if projection is None:
return {"state": "identity_conflict", "identity_key": identity_key, "person_id": person_id}
projection["resolved_identity_key"] = identity_key
return {"state": "resolved", "identity_key": identity_key, "person_id": person_id, "projection": projection}
def _migration_context(identity_context: dict[str, Any] | None) -> dict[str, str] | None:
"""Accept only an explicit source context; legacy IDs alone are not identities."""
if not isinstance(identity_context, dict):
return None
try:
return {
"companion_instance_id": _text(identity_context.get("companion_instance_id"), "companion_instance_id"),
"bot_account_id": _text(identity_context.get("bot_account_id"), "bot_account_id"),
"adapter_instance_id": _text(identity_context.get("adapter_instance_id"), "adapter_instance_id"),
"subject_namespace": _text(identity_context.get("subject_namespace"), "subject_namespace").lower(),
}
except ValueError:
return None
def _identity_for_subject(context: dict[str, str], subject_id: Any) -> dict[str, str]:
identity = dict(context)
identity["platform_subject_id"] = _text(subject_id, "platform_subject_id")
return identity
def _legacy_display_name(record: dict[str, Any], subject_id: str) -> str:
for field in ("nickname", "name", "display_name"):
value = str(record.get(field) or "").strip()
if value:
return value[:120]
return subject_id[:120]
def preview_unified_person_migration(
store: dict[str, Any],
*,
identity_context: dict[str, Any] | None = None,
private_user_aliases: dict[str, Any] | None = None,
owner_user_ids: set[str] | list[str] | tuple[str, ...] = (),
) -> dict[str, Any]:
"""Produce a non-mutating migration plan and explicitly flag ambiguous legacy data."""
context = _migration_context(identity_context)
if context is None:
return {
"ok": False,
"mode": "preview",
"migration_version": UNIFIED_PERSON_MIGRATION_VERSION,
"contract_name": CONTRACT_NAME,
"contract_version": CONTRACT_VERSION,
"contract_fingerprint": CONTRACT_FINGERPRINT,
"coordination_status": "legacy_unresolved",
"error_code": "identity_context_incomplete",
"would_create_profiles": 0,
"would_create_identity_links": 0,
"would_create_group_overlays": 0,
"legacy_affinity_baselines": 0,
"legacy_alias_candidates": 0,
"warnings": ["Migration requires explicit companion, bot, adapter, and subject namespace context."],
"rollback": "No migration was applied.",
}
users = store.get("users") if isinstance(store, dict) and isinstance(store.get("users"), dict) else {}
groups = store.get("groups") if isinstance(store, dict) and isinstance(store.get("groups"), dict) else {}
aliases = private_user_aliases if isinstance(private_user_aliases, dict) else {}
owner_ids = {str(item).strip() for item in owner_user_ids if str(item).strip()}
planned_profiles: dict[str, str] = {}
overlay_count = 0
warnings: list[str] = []
legacy_score_count = 0
for user_id, record in users.items():
subject_id = str(user_id or "").strip()
if not subject_id:
warnings.append("legacy user with empty user_id skipped")
continue
identity = _identity_for_subject(context, subject_id)
planned_profiles[subject_id] = person_id_for_identity(identity)
if isinstance(record, dict) and "relationship_score" in record:
legacy_score_count += 1
if isinstance(record, dict) and str(record.get("relationship_role") or "").strip().lower() in {"owner", "master", "主人"} and subject_id not in owner_ids:
warnings.append(f"legacy owner role for {subject_id} requires backend owner confirmation")
for group_id, group in groups.items():
members = group.get("members") if isinstance(group, dict) and isinstance(group.get("members"), dict) else {}
for member_id in members:
subject_id = str(member_id or "").strip()
if not subject_id:
continue
planned_profiles.setdefault(subject_id, person_id_for_identity(_identity_for_subject(context, subject_id)))
overlay_count += 1
alias_count = 0
for alias, canonical in aliases.items():
alias_text = str(alias or "").strip()
canonical_text = str(canonical or "").strip()
if not alias_text or not canonical_text:
warnings.append("empty private_user_aliases entry skipped")
continue
if canonical_text not in planned_profiles:
warnings.append(f"alias {alias_text} targets unknown legacy user {canonical_text}")
continue
alias_count += 1
warnings.append(f"legacy private_user_alias {alias_text} -> {canonical_text} retained for owner confirmation; no identity link will be created")
return {
"ok": True,
"mode": "preview",
"migration_version": UNIFIED_PERSON_MIGRATION_VERSION,
"contract_name": CONTRACT_NAME,
"contract_version": CONTRACT_VERSION,
"contract_fingerprint": CONTRACT_FINGERPRINT,
"identity_context": deepcopy(context),
"would_create_profiles": len(planned_profiles),
"would_create_identity_links": len(planned_profiles),
"legacy_alias_candidates": alias_count,
"would_create_group_overlays": overlay_count,
"legacy_affinity_baselines": legacy_score_count,
"warnings": warnings,
"rollback": "Restores the pre-migration unified_person section; legacy users, aliases, groups, and scores are never deleted.",
}
def apply_unified_person_migration(
store: dict[str, Any],
*,
identity_context: dict[str, Any] | None = None,
private_user_aliases: dict[str, Any] | None = None,
owner_user_ids: set[str] | list[str] | tuple[str, ...] = (),
migration_id: str = "legacy_v1",
now: str | None = None,
) -> dict[str, Any]:
"""Apply the reviewed migration idempotently and retain a scoped rollback snapshot."""
report = preview_unified_person_migration(
store,
identity_context=identity_context,
private_user_aliases=private_user_aliases,
owner_user_ids=owner_user_ids,
)
migration_id = _text(migration_id, "migration_id", limit=80)
if not report.get("ok"):
return {
**report,
"mode": "apply",
"applied": False,
"idempotent": False,
"migration_id": migration_id,
}
ensure_unified_person_store(store)
root = store["unified_person"]
migration = root["migration"]
applied = migration["applied_ids"]
if migration_id in applied:
return {**report, "mode": "apply", "applied": False, "idempotent": True, "migration_id": migration_id}
backup = deepcopy(root)
backup_migration = backup.get("migration") if isinstance(backup.get("migration"), dict) else {}
backup_migration["backups"] = {}
backup["migration"] = backup_migration
migration["backups"][migration_id] = backup
context = _migration_context(identity_context)
if context is None: # Guard for future changes to preview semantics.
return {**report, "mode": "apply", "applied": False, "idempotent": False, "migration_id": migration_id}
owner_ids = {str(item).strip() for item in owner_user_ids if str(item).strip()}
users = store.get("users") if isinstance(store.get("users"), dict) else {}
groups = store.get("groups") if isinstance(store.get("groups"), dict) else {}
timestamp = now or _utc_now()
def add_subject(subject_id: str, record: dict[str, Any] | None = None) -> str:
identity = _identity_for_subject(context, subject_id)
identity_key = build_identity_key(identity)
person_id = person_id_for_identity(identity)
profiles = root["profiles"]
if person_id not in profiles:
source = record if isinstance(record, dict) else {}
score = _safe_score(source.get("relationship_score"))
profiles[person_id] = {
"person_id": person_id,
"resolved_identity_key": identity_key,
"identity_assurance": "unverified",
"profile_status": "active",
"display_name": _legacy_display_name(source, subject_id),
"aliases": _safe_aliases(source.get("alias_user_ids")),
"relation_policy_id": "default_friend",
"owner_mode": "owner" if subject_id in owner_ids else "not_owner",
"affinity_score": score,
"affinity_baseline": {"source": "legacy_relationship_score", "value": score},
"warning_stage": "none",
"confinement_state": "none",
"confinement_until": "",
"release_prompt_pending": False,
"proactive_private_enabled": False,
"group_overlay_ref": "",
"projection_revision": 1,
"updated_at": timestamp,
}
root["identity_links"].setdefault(identity_key, {
"identity_key": identity_key,
"identity": identity,
"person_id": person_id,
"identity_assurance": "unverified",
"status": "active",
"origin": "legacy_migration",
"created_at": timestamp,
})
return person_id
for user_id, record in users.items():
subject_id = str(user_id or "").strip()
if subject_id:
add_subject(subject_id, record if isinstance(record, dict) else None)
for group_id, group in groups.items():
members = group.get("members") if isinstance(group, dict) and isinstance(group.get("members"), dict) else {}
for member_id, member in members.items():
subject_id = str(member_id or "").strip()
if not subject_id:
continue
person_id = add_subject(subject_id, member if isinstance(member, dict) else None)
overlay_key = f"{str(group_id)}:{person_id}"
root["group_overlays"].setdefault(overlay_key, {
"group_id": str(group_id),
"person_id": person_id,
"origin_identity_key": build_identity_key(_identity_for_subject(context, subject_id)),
"legacy_member": deepcopy(member) if isinstance(member, dict) else {},
"created_at": timestamp,
})
aliases = private_user_aliases if isinstance(private_user_aliases, dict) else {}
legacy_alias_candidates: list[dict[str, str]] = []
for alias, canonical in aliases.items():
alias_text, canonical_text = str(alias or "").strip(), str(canonical or "").strip()
if not alias_text or not canonical_text:
continue
canonical_key = build_identity_key(_identity_for_subject(context, canonical_text))
if not isinstance(root["identity_links"].get(canonical_key), dict):
continue
legacy_alias_candidates.append({"alias": alias_text, "canonical": canonical_text})
if legacy_alias_candidates:
root["migration"].setdefault("legacy_alias_candidates", [])
existing_candidates = root["migration"]["legacy_alias_candidates"]
for candidate in legacy_alias_candidates:
if candidate not in existing_candidates:
existing_candidates.append(candidate)
applied.append(migration_id)
migration["version"] = UNIFIED_PERSON_MIGRATION_VERSION
return {**report, "mode": "apply", "applied": True, "idempotent": False, "migration_id": migration_id}
def rollback_unified_person_migration(store: dict[str, Any], migration_id: str) -> dict[str, Any]:
"""Restore the scoped pre-migration section without touching legacy source data."""
ensure_unified_person_store(store)
migration_id = _text(migration_id, "migration_id", limit=80)
root = store["unified_person"]
backup = root["migration"]["backups"].get(migration_id)
if not isinstance(backup, dict):
return {"ok": False, "rolled_back": False, "reason": "migration backup not found", "migration_id": migration_id}
restored = deepcopy(backup)
restored_migration = restored.get("migration") if isinstance(restored.get("migration"), dict) else {}
restored_migration["backups"] = deepcopy(root["migration"].get("backups") or {})
restored["migration"] = restored_migration
store["unified_person"] = restored
return {"ok": True, "rolled_back": True, "migration_id": migration_id}