refactor: unified record_turn_memory API with you_present kwarg (T84)

Extends record_turn_memory_for_present with a you_present: bool = True
kwarg so a single entry-point covers both you-scenes (witness_you=1)
and meanwhile scenes (witness_you=0). Validates that meanwhile callers
provide a guest_bot_id.

record_meanwhile_memory becomes a thin backward-compat wrapper that
delegates with you_present=False, preserving the call site in
chat/web/meanwhile.py without churn.

chat/services/memory_write.py

@@ -134,17 +134,34 @@ def record_turn_memory_for_present(
     chat_clock_at: str | None = None,
     source: str = "direct",
     significance: int = 1,
+    you_present: bool = True,
 ) -> dict[str, tuple[int, int | None]]:
-    """Write a ``memory_written`` event for each present bot witness.
+    """Single entry-point for per-turn memory writes (T84).
 
-    Host is always written. Guest is written iff ``guest_bot_id is not
-    None``. Witness flags are ``[you=1, host=1, guest=1]`` when a guest
-    is present, ``[you=1, host=1, guest=0]`` otherwise.
+    Writes one ``memory_written`` event per present bot witness. Host is
+    always written. Guest is written iff ``guest_bot_id is not None``.
+
+    Witness flags depend on ``you_present``:
+
+    - ``you_present=True`` (default — Phase 1/2/3 you-scenes): the user
+      is a witness. Mask is ``[you=1, host=1, guest=1]`` when a guest is
+      present, ``[you=1, host=1, guest=0]`` otherwise.
+    - ``you_present=False`` (Phase 3 meanwhile scenes): the user is
+      absent. Mask is ``[you=0, host=1, guest=1]`` for both bots. Both
+      ``host_bot_id`` and ``guest_bot_id`` are required — a meanwhile
+      scene by definition has both bots, so passing ``guest_bot_id=None``
+      with ``you_present=False`` is a programming error and raises
+      :class:`ValueError`.
 
     Returns a mapping ``{bot_id: (event_id, memory_id)}`` so callers can
     look up the freshly-projected memory id per owner without re-querying
     the database.
     """
+    if not you_present and guest_bot_id is None:
+        raise ValueError("you_present=False requires guest_bot_id")
+
+    witness_you = 1 if you_present else 0
+    witness_host = 1
     witness_guest = 1 if guest_bot_id is not None else 0
 
     result: dict[str, tuple[int, int | None]] = {}
@@ -153,8 +170,8 @@ def record_turn_memory_for_present(
         owner_id=host_bot_id,
         chat_id=chat_id,
         narrative_text=narrative_text,
-        witness_you=1,
-        witness_host=1,
+        witness_you=witness_you,
+        witness_host=witness_host,
         witness_guest=witness_guest,
         scene_id=scene_id,
         chat_clock_at=chat_clock_at,
@@ -167,8 +184,8 @@ def record_turn_memory_for_present(
             owner_id=guest_bot_id,
             chat_id=chat_id,
             narrative_text=narrative_text,
-            witness_you=1,
-            witness_host=1,
+            witness_you=witness_you,
+            witness_host=witness_host,
             witness_guest=1,
             scene_id=scene_id,
             chat_clock_at=chat_clock_at,
@@ -190,46 +207,22 @@ def record_meanwhile_memory(
     source: str = "direct",
     significance: int = 1,
 ) -> dict[str, tuple[int, int | None]]:
-    """Write per-POV ``memory_written`` events for a meanwhile turn (T64).
+    """Backward-compat thin wrapper for meanwhile memory writes (T64, T84).
 
-    A meanwhile scene runs entirely between host + guest, with "you"
-    absent. Both bots are present witnesses, so each one gets a row with
-    witness flags ``[you=0, host=1, guest=1]`` — different from the
-    normal-turn ``record_turn_memory_for_present`` shape, which assumes
-    the user is always a witness (``witness_you=1``).
-
-    The ``guest_bot_id`` is required (a meanwhile scene by definition
-    has both bots) — callers passing ``None`` is a programming error.
-
-    Returns ``{bot_id: (event_id, memory_id)}`` mirroring
-    :func:`record_turn_memory_for_present` so downstream queues
-    (significance scoring) can pull memory ids without re-querying.
+    Equivalent to calling :func:`record_turn_memory_for_present` with
+    ``you_present=False``. Kept so existing call sites in
+    :mod:`chat.web.meanwhile` continue to work without churn. New code
+    should prefer the unified entry-point directly.
     """
-    result: dict[str, tuple[int, int | None]] = {}
-    result[host_bot_id] = _write_one_memory(
+    return record_turn_memory_for_present(
         conn,
-        owner_id=host_bot_id,
         chat_id=chat_id,
+        host_bot_id=host_bot_id,
+        guest_bot_id=guest_bot_id,
         narrative_text=narrative_text,
-        witness_you=0,
-        witness_host=1,
-        witness_guest=1,
         scene_id=scene_id,
         chat_clock_at=chat_clock_at,
         source=source,
         significance=significance,
+        you_present=False,
     )
-    result[guest_bot_id] = _write_one_memory(
-        conn,
-        owner_id=guest_bot_id,
-        chat_id=chat_id,
-        narrative_text=narrative_text,
-        witness_you=0,
-        witness_host=1,
-        witness_guest=1,
-        scene_id=scene_id,
-        chat_clock_at=chat_clock_at,
-        source=source,
-        significance=significance,
-    )
-    return result