Say truthfully how the earlier memory is folded

The one-time legacy-memory notice ended with "To fold it all now, ask
Ouroboros to fold the old memory." That promise did not hold: on the
acceptance stand one such request folded 23 of 377 retellings. Folding
happens part by part, and the host knows neither how long the rest takes
nor what it costs, so the notice now states only facts: the old memory
works as it is, it is folded into the new format gradually, part by part,
and the owner can ask Ouroboros to keep folding it; Ouroboros sees its
story status ("folded X of Y blocks") and can say how much is left.

The test pins the new sentence and refuses any one-request promise
("all now", "at once", "fold it all"), which the previous wording trips.

The text stays English. The neighbouring one-time notices (reviewer
default, optional bounds, retired settings) are plain English system rows
too: the browser renders system rows as escaped text inside the chat
transcript, which the translation overlay never walks, and no host-side
tr()/fmt() call covers them, so there is no existing mechanism to route
this notice through without inventing one.

ouroboros/upgrade_notices.py

@@ -7,7 +7,8 @@ reviewer panel follows whatever panel ships. Neither is migrated silently or
 behind the owner's back; each is stated ONCE, factually, in the owner's chat.
 The same holds for the memory the old dialogue writer left: the chronicle
 imports it unchanged, it keeps working in that format and is folded gradually,
-and the owner hears once how much of it there is and how to fold it at once.
+and the owner hears once how much of it there is and that Ouroboros can be asked
+to keep folding it, part by part.
 
 The facts are only what the document, the environment and the imported memory
 show — a key absent from the document, an invalid value, a saved value, an
@@ -163,9 +164,12 @@ def legacy_memory_notice(facts: Optional[Mapping[str, Any]]) -> str:
         amount += f" ({start} to {end})" if start != end else f" ({start})"
     elif labels:
         amount += f" (labelled {labels[0]} … {labels[-1]})" if labels[0] != labels[-1] else f" (labelled {labels[0]})"
+    # Facts only: one request folds a part, not the whole (on the acceptance stand 23 of 377
+    # retellings), and the host knows neither the time nor the price of the rest; the mind
+    # sees its story status and can say how much is left.
     return ("🧠 Memory: what Ouroboros remembered before this update is kept in its previous format — "
-            f"{amount}. It works as it is and is folded into the new format gradually. "
-            "To fold it all now, ask Ouroboros to fold the old memory.")
+            f"{amount}. It works as it is and is folded into the new format gradually, part by part. "
+            "You can ask Ouroboros to keep folding it; it will tell you how much is left.")
 
 
 def _raw_settings_document() -> Optional[Dict[str, Any]]:

tests/test_legacy_memory_notice.py

@@ -84,8 +84,8 @@ def test_an_install_with_old_memory_hears_once_how_much_and_how_to_fold_it(boot)
     assert len(rows) == 1 and rows[0]["direction"] == "system" and rows[0]["chat_id"] == 7
     text = rows[0]["text"]
     assert "3 pieces over 2 periods (2026-08-01 to 2026-09-05)" in text  # the sections' own chat rows
-    assert "works as it is" in text and "folded into the new format gradually" in text
-    assert "ask Ouroboros to fold the old memory" in text
+    assert "works as it is" in text and "folded into the new format gradually, part by part" in text
+    assert "ask Ouroboros to keep folding it; it will tell you how much is left" in text
     assert boot.state.load_state()[notices.LEGACY_MEMORY_NOTICE_KEY]
     # The facts came from the same import the first memory view runs, and the old files are untouched.
     store = ChronicleStore(boot.root)
@@ -240,9 +240,14 @@ def test_an_unreadable_journal_leaves_only_this_notice_owed(boot, monkeypatch):
 ])
 def test_the_notice_states_facts_only(facts, expected):
     text = notices.legacy_memory_notice(facts)
-    assert expected in text and text.endswith("ask Ouroboros to fold the old memory.")
+    assert expected in text and text.endswith("it will tell you how much is left.")
     # No price, duration, schedule or UI surface: the owner decides on facts.
     for word in ("$", "cost", "minute", "hour", "second", "first turn", "Settings"):
         assert word not in text
+    # No promise that one request folds everything: on the acceptance stand one request
+    # folded 23 of 377 retellings. The previous wording ("To fold it all now, ask ...") trips this.
+    for promise in ("all now", "at once", "fold it all"):
+        assert promise not in text
+    assert "part by part" in text and "keep folding" in text
     assert notices.legacy_memory_notice({**facts, "pieces": 0}) == ""
     assert notices.legacy_memory_notice(None) == ""