助手撤销刚才的修改，为什么不能直接盖回旧稿？

"""Flat string fields with per-field revision checks; single-process simulation."""
from copy import deepcopy
from dataclasses import dataclass, field
import json
from pathlib import Path


@dataclass
class Store:
    values: dict[str, str]
    revisions: dict[str, int] = field(default_factory=dict)

    def __post_init__(self):
        self.values = deepcopy(self.values)
        self.revisions = {key: 0 for key in self.values}

    def state(self, key):
        return {"present": key in self.values, "value": self.values.get(key),
                "revision": self.revisions.get(key, 0)}

    def put(self, key, value):
        if not isinstance(key, str) or not key:
            raise ValueError("nonempty_string_key_required")
        if value is not None and not isinstance(value, str):
            raise ValueError("string_or_delete_required")
        if value is None:
            self.values.pop(key, None)
        else:
            self.values[key] = value
        # A tombstone revision remains even after deletion.
        self.revisions[key] = self.revisions.get(key, 0) + 1


def apply(store, edits):
    # Validate the complete request before mutating this local store.
    if any(not isinstance(k, str) or not k or
           (v is not None and not isinstance(v, str)) for k, v in edits.items()):
        raise ValueError("invalid_edit")
    journal = []
    for key, value in edits.items():
        before = store.state(key)
        store.put(key, value)
        journal.append({"field": key, "before": before, "after": store.state(key)})
    return journal


def undo(store, journal):
    # All guards checked first: one conflict means no fields are reverted.
    conflicts = []
    for entry in journal:
        current = store.state(entry["field"])
        if current != entry["after"]:
            conflicts.append({"field": entry["field"], "expected": entry["after"],
                              "current": current})
    if conflicts:
        return {"status": "conflict", "reverted": [], "conflicts": conflicts}
    for entry in reversed(journal):
        old = entry["before"]
        store.put(entry["field"], old["value"] if old["present"] else None)
    return {"status": "reverted", "reverted": [e["field"] for e in journal], "conflicts": []}


def scenario(name, later_edits):
    store = Store({"title": "Tea draft", "phone": "010-1000", "hours": "09:00-18:00"})
    original = deepcopy(store.values)
    journal = apply(store, {"title": "Tea final", "phone": None, "note": "upstairs"})
    for edits in later_edits:
        apply(store, edits)
    before_undo = deepcopy(store.values)
    result = undo(store, journal)
    after_undo = deepcopy(store.values)
    repeat = undo(store, journal)
    assert repeat["status"] == "conflict"  # stale journal is never silently reused
    assert store.values == after_undo
    if result["status"] == "conflict":
        assert before_undo == after_undo
    return {"case": name, "original": original, "journal": journal,
            "before_undo": before_undo, "result": result, "after_undo": after_undo,
            "repeat_status": repeat["status"]}


def main():
    cases = [
        scenario("unrelated_edit", [{"hours": "10:00-19:00"}]),
        scenario("same_field_conflict", [{"title": "Someone else's title"}]),
        scenario("changed_away_and_back", [{"title": "Other title"}, {"title": "Tea final"}]),
        scenario("deleted_field_recreated", [{"phone": "010-3000"}]),
    ]
    safe, conflict, aba, recreated = cases
    assert safe["result"]["status"] == "reverted"
    assert safe["after_undo"] == {"title": "Tea draft", "phone": "010-1000", "hours": "10:00-19:00"}
    assert conflict["result"]["status"] == aba["result"]["status"] == recreated["result"]["status"] == "conflict"
    assert aba["before_undo"]["title"] == "Tea final"
    assert aba["result"]["conflicts"][0]["current"]["revision"] == 3
    assert aba["result"]["conflicts"][0]["expected"]["revision"] == 1
    assert conflict["after_undo"]["note"] == "upstairs" and "phone" not in conflict["after_undo"]
    assert recreated["after_undo"]["phone"] == "010-3000"
    probe = Store({"title": "untouched"})
    try:
        apply(probe, {"title": "would change", "bad": 123})
    except ValueError:
        pass
    else:
        raise AssertionError("invalid batch accepted")
    assert probe.values == {"title": "untouched"} and probe.revisions == {"title": 0}
    report = {"scope": "single-thread, flat string fields; all writes pass through Store",
              "policy": "all-or-nothing guards per undo batch; revisions never roll back",
              "cases": cases, "assertions": "passed"}
    Path("conditional-undo-report.json").write_text(
        json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    for row in cases:
        print(f"{row['case']}: {row['result']['status']}; repeat={row['repeat_status']}")
    print("PASS: unrelated edit preserved, conflicts atomic, ABA detected, deletion tracked")


if __name__ == "__main__":
    main()