unique-user-memory 2026.32.0.dev0__tar.gz → 2026.32.0.dev2__tar.gz

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.3
 Name: unique-user-memory
-Version: 2026.32.0.dev0
+Version: 2026.32.0.dev2
 Summary: 
 Author: Fabian Schläpfer
 Author-email: Fabian Schläpfer <fabian@unique.ch>
 License: Proprietary
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: pydantic>=2.8.2
-Requires-Dist: unique-sdk>=2026.32.0.dev0,<2026.32.0rc0
-Requires-Dist: unique-toolkit>=2026.32.0.dev0,<2026.32.0rc0
+Requires-Dist: unique-sdk>=2026.32.0.dev5,<2026.32.0rc0
+Requires-Dist: unique-toolkit>=2026.32.0.dev4,<2026.32.0rc0
 Requires-Python: >=3.12, <4
 Description-Content-Type: text/markdown
 
@@ -16,7 +16,7 @@ Description-Content-Type: text/markdown
 
 Persistent per-user memory for Unique AI agents.
 
-`unique_user_memory` stores a compact Markdown profile for each user and updates it after every agent turn. The profile is loaded before the next turn so the assistant can remember stable user context such as communication preferences, work context, expertise, recent topics, and open follow-ups.
+`unique_user_memory` stores a compact Markdown profile for each user and updates it after every agent turn. The profile is loaded before the next turn so the assistant can remember stable user context such as communication preferences, work context, expertise, recent topics, and concrete future tasks.
 
 ## What It Does
 
@@ -76,7 +76,7 @@ _(empty)_
 ## Recent Topics
 _(empty)_
 
-## Open Questions / Follow-ups
+## Follow-ups
 _(empty)_
 ```
 

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/README.md

@@ -2,7 +2,7 @@
 
 Persistent per-user memory for Unique AI agents.
 
-`unique_user_memory` stores a compact Markdown profile for each user and updates it after every agent turn. The profile is loaded before the next turn so the assistant can remember stable user context such as communication preferences, work context, expertise, recent topics, and open follow-ups.
+`unique_user_memory` stores a compact Markdown profile for each user and updates it after every agent turn. The profile is loaded before the next turn so the assistant can remember stable user context such as communication preferences, work context, expertise, recent topics, and concrete future tasks.
 
 ## What It Does
 
@@ -62,7 +62,7 @@ _(empty)_
 ## Recent Topics
 _(empty)_
 
-## Open Questions / Follow-ups
+## Follow-ups
 _(empty)_
 ```
 

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_user_memory"
-version = "2026.32.0.dev0"
+version = "2026.32.0.dev2"
 description = ""
 authors = [
     { name = "Fabian Schläpfer", email = "fabian@unique.ch" },
@@ -11,8 +11,8 @@ requires-python = ">=3.12,<4"
 dependencies = [
     "jinja2>=3.1.6",
     "pydantic>=2.8.2",
-    "unique-sdk>=2026.32.0.dev0,<2026.32.0rc0",
-    "unique-toolkit>=2026.32.0.dev0,<2026.32.0rc0",
+    "unique-sdk>=2026.32.0.dev5,<2026.32.0rc0",
+    "unique-toolkit>=2026.32.0.dev4,<2026.32.0rc0",
 ]
 
 [dependency-groups]

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/unique_user_memory/tests/test_user_memory.py

@@ -6,6 +6,8 @@ from unique_toolkit.language_model.default_language_model import (
     DEFAULT_LANGUAGE_MODEL,
 )
 from unique_toolkit.language_model.infos import LanguageModelInfo
+from unique_toolkit.language_model.invocation_stats import LanguageModelInvocationStats
+from unique_toolkit.language_model.schemas import LanguageModelTokenUsage
 
 from unique_user_memory.config import UserMemoryConfig
 from unique_user_memory.user_memory import (
@@ -23,11 +25,26 @@ from unique_user_memory.user_memory import (
     upload_user_memory,
 )
 from unique_user_memory.user_memory_postprocessor import UserMemoryPostprocessor
-from unique_user_memory.user_memory_prompts import empty_profile
+from unique_user_memory.user_memory_prompts import (
+    consolidation_system_prompt,
+    empty_profile,
+    memory_gate_system_prompt,
+)
 
 _TEST_LANGUAGE_MODEL = LanguageModelInfo.from_name(DEFAULT_LANGUAGE_MODEL)
 
 
+def test_memory_profile_keeps_follow_up_tasks_but_excludes_open_questions() -> None:
+    profile = empty_profile("user_1")
+    consolidation_prompt = consolidation_system_prompt(2000)
+    gate_prompt = memory_gate_system_prompt()
+
+    assert "## Open Questions / Follow-ups" not in profile
+    assert "## Follow-ups" in profile
+    assert "concrete tasks the user intends to complete" in consolidation_prompt
+    assert "Concrete future tasks the user intends to complete" in gate_prompt
+
+
 def test_enforce_token_cap_truncates_long_content() -> None:
     content = "\n\n".join(f"paragraph {index} " + "word " * 40 for index in range(50))
 
@@ -144,6 +161,35 @@ async def test_condense_user_memory_rejects_non_profile_output(
     assert result is None
 
 
+@pytest.mark.ai
+@pytest.mark.asyncio
+async def test_condense_user_memory_accepts_frontmatter_output(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Accept legacy LLM output while returning only the condensed profile body."""
+    condensed = "# User Memory\n\n## Identity\n- concise summary"
+    response = MagicMock()
+    response.choices[0].message.content = (
+        "---\nuser_id: stale-user\nturn_count: 99\n---\n\n" + condensed
+    )
+    llm_service = MagicMock()
+    llm_service.complete_async = AsyncMock(return_value=response)
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.LanguageModelService",
+        MagicMock(return_value=llm_service),
+    )
+
+    result = await condense_user_memory(
+        content="# User Memory\n\n## Identity\n- lots of stuff",
+        max_tokens=2000,
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=MagicMock(),
+        logger=MagicMock(),
+    )
+
+    assert result == condensed
+
+
 def test_count_tokens_uses_language_model_encoder() -> None:
     language_model = MagicMock()
     language_model.get_encoder.return_value = lambda content: content.split()
@@ -281,10 +327,86 @@ async def test_consolidate_user_memory_runs_full_rewrite_when_gate_update(
         logger=MagicMock(),
     )
 
-    assert result == rewritten
+    assert result.endswith(f"{rewritten}\n")
+    assert "user_id: user_1" in result
+    assert "schema_version: 1" in result
+    assert "turn_count: 1" in result
     llm_service.complete_async.assert_awaited_once()
 
 
+@pytest.mark.asyncio
+async def test_consolidate_user_memory_adds_frontmatter_to_llm_body(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    rewritten = "# User Memory\n\n## Identity\n- Prefers concise answers"
+    response = MagicMock()
+    response.choices[0].message.content = rewritten
+    llm_service = MagicMock()
+    llm_service.complete_async = AsyncMock(return_value=response)
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.LanguageModelService",
+        MagicMock(return_value=llm_service),
+    )
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.should_consolidate_memory",
+        AsyncMock(return_value=True),
+    )
+
+    result = await consolidate_user_memory(
+        current_memory="",
+        user_id="authenticated-user",
+        user_message="remember I like concise answers",
+        assistant_message="noted",
+        config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=MagicMock(),
+        logger=MagicMock(),
+    )
+
+    assert "user_id: authenticated-user" in result
+    assert "schema_version: 1" in result
+    assert "turn_count: 1" in result
+
+
+@pytest.mark.ai
+@pytest.mark.asyncio
+async def test_consolidate_user_memory_replaces_llm_frontmatter(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Strip untrusted legacy metadata before assembling the updated profile."""
+    rewritten = "# User Memory\n\n## Identity\n- Prefers concise answers"
+    response = MagicMock()
+    response.choices[0].message.content = (
+        "---\nuser_id: stale-user\nturn_count: 99\n---\n\n" + rewritten
+    )
+    llm_service = MagicMock()
+    llm_service.complete_async = AsyncMock(return_value=response)
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.LanguageModelService",
+        MagicMock(return_value=llm_service),
+    )
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.should_consolidate_memory",
+        AsyncMock(return_value=True),
+    )
+
+    result = await consolidate_user_memory(
+        current_memory=empty_profile("authenticated-user"),
+        user_id="authenticated-user",
+        user_message="remember I like concise answers",
+        assistant_message="noted",
+        config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=MagicMock(),
+        logger=MagicMock(),
+    )
+
+    assert result.endswith(f"{rewritten}\n")
+    assert "user_id: authenticated-user" in result
+    assert "stale-user" not in result
+    assert "turn_count: 1" in result
+
+
 @pytest.mark.asyncio
 async def test_consolidate_user_memory_skips_gate_when_disabled(
     monkeypatch: pytest.MonkeyPatch,
@@ -316,7 +438,9 @@ async def test_consolidate_user_memory_skips_gate_when_disabled(
         logger=MagicMock(),
     )
 
-    assert result == rewritten
+    assert result.endswith(f"{rewritten}\n")
+    assert "user_id: user_1" in result
+    assert "turn_count: 1" in result
     gate.assert_not_awaited()
     llm_service.complete_async.assert_awaited_once()
 
@@ -434,7 +558,9 @@ async def test_consolidate_user_memory_invokes_update_callbacks_on_rewrite(
         on_update_end=on_end,
     )
 
-    assert result == rewritten
+    assert result.endswith(f"{rewritten}\n")
+    assert "user_id: user_1" in result
+    assert "turn_count: 1" in result
     on_start.assert_awaited_once()
     on_end.assert_awaited_once()
     assert events == ["start", "end"]
@@ -964,6 +1090,106 @@ async def test_user_memory_postprocessor_logs_success_when_upload_succeeds(
     )
 
 
+@pytest.mark.ai
+@pytest.mark.asyncio
+async def test_user_memory_postprocessor_run_resets_invocation_stats(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Purpose: Verify each run reports only usage attributable to that run.
+    Why this matters: Reused postprocessors must not inflate token analytics.
+    Setup summary: Run twice with distinct usage and assert the second excludes the first.
+    """
+    load_stats = LanguageModelInvocationStats.from_usage(
+        _TEST_LANGUAGE_MODEL.name,
+        LanguageModelTokenUsage(total_tokens=2),
+        source="user_memory_load_condense",
+    )
+    first_run_stats = LanguageModelInvocationStats.from_usage(
+        _TEST_LANGUAGE_MODEL.name,
+        LanguageModelTokenUsage(total_tokens=3),
+        source="user_memory_consolidate_first",
+    )
+    second_run_stats = LanguageModelInvocationStats.from_usage(
+        _TEST_LANGUAGE_MODEL.name,
+        LanguageModelTokenUsage(total_tokens=5),
+        source="user_memory_consolidate_second",
+    )
+    run_stats = iter((first_run_stats, second_run_stats))
+
+    async def consolidate(*, invocation_stats, **kwargs) -> str:  # type: ignore[no-untyped-def]
+        invocation_stats.append(next(run_stats))
+        return "# User Memory\n\n## Identity\n- unchanged"
+
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory_postprocessor.consolidate_user_memory",
+        consolidate,
+    )
+    event = MagicMock()
+    event.user_id = "user_1"
+    event.company_id = "company_1"
+    event.payload.user_message.text = "remember this"
+    loop_response = MagicMock()
+    loop_response.message.text = "noted"
+    state = UserMemoryState(
+        scope_id="scope_1",
+        text="# User Memory\n\n## Identity\n- unchanged",
+        load_invocation_stats=(load_stats,),
+    )
+    postprocessor = UserMemoryPostprocessor(
+        config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=event,
+        state=state,
+        logger=MagicMock(),
+        chat_service=MagicMock(),
+    )
+
+    await postprocessor.run(loop_response)
+    first_reported_stats = postprocessor.invocation_stats
+    await postprocessor.run(loop_response)
+
+    assert first_reported_stats == [load_stats, first_run_stats]
+    assert postprocessor.invocation_stats == [second_run_stats]
+
+
+@pytest.mark.ai
+def test_user_memory_postprocessor_take_pending_invocation_stats_drains_once() -> None:
+    """Purpose: Verify load-time usage is reported exactly once, however it's read.
+    Why this matters: A turn that exits before `run()` (cancellation, empty
+    response, a control-taking tool) must still report the load-time condense
+    tokens, and a turn that does reach `run()` must not double-count them.
+    Setup summary: Take the pending stats directly, then run(), and assert
+    run() no longer reports the already-taken load stats.
+    """
+    load_stats = LanguageModelInvocationStats.from_usage(
+        _TEST_LANGUAGE_MODEL.name,
+        LanguageModelTokenUsage(total_tokens=2),
+        source="user_memory_load_condense",
+    )
+    event = MagicMock()
+    event.user_id = "user_1"
+    event.company_id = "company_1"
+    event.payload.user_message.text = "remember this"
+    state = UserMemoryState(
+        scope_id="scope_1",
+        text="# User Memory\n\n## Identity\n- unchanged",
+        load_invocation_stats=(load_stats,),
+    )
+    postprocessor = UserMemoryPostprocessor(
+        config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=event,
+        state=state,
+        logger=MagicMock(),
+        chat_service=MagicMock(),
+    )
+
+    taken = postprocessor.take_pending_invocation_stats()
+
+    assert taken == [load_stats]
+    assert postprocessor.take_pending_invocation_stats() == []
+
+
 @pytest.mark.asyncio
 async def test_user_memory_postprocessor_does_not_log_success_when_upload_fails(
     monkeypatch: pytest.MonkeyPatch,

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/unique_user_memory/user_memory.py

@@ -1,6 +1,7 @@
 import re
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from logging import Logger
 
 import unique_sdk
@@ -20,6 +21,9 @@ from unique_toolkit.language_model import (
     TypeEncoder,
 )
 from unique_toolkit.language_model.infos import LanguageModelInfo
+from unique_toolkit.language_model.invocation_stats import (
+    LanguageModelInvocationStats,
+)
 
 from unique_user_memory.config import UserMemoryConfig
 from unique_user_memory.user_memory_prompts import (
@@ -56,12 +60,47 @@ _CONDENSE_TARGET_RATIO = 0.9
 _TRUNCATION_MARKER = "\n\n<!-- truncated to fit memory budget -->"
 _DEFAULT_LANGUAGE_MODEL = LanguageModelInfo.from_name(DEFAULT_GPT_4o)
 _FRONTMATTER_RE = re.compile(r"^---\n.*?\n---\n", re.DOTALL)
+_TURN_COUNT_RE = re.compile(r"^turn_count:\s*(\d+)\s*$", re.MULTILINE)
+
+
+def _profile_body(content: str) -> str:
+    return _FRONTMATTER_RE.sub("", content, count=1).strip()
+
+
+def _turn_count(content: str) -> int:
+    frontmatter_match = _FRONTMATTER_RE.match(content)
+    if frontmatter_match is None:
+        return 0
+    match = _TURN_COUNT_RE.search(frontmatter_match.group(0))
+    return int(match.group(1)) if match else 0
+
+
+def _assemble_profile(*, body: str, user_id: str, turn_count: int) -> str:
+    """Prefix an LLM-generated body with trusted application metadata."""
+    timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    return (
+        "---\n"
+        f"user_id: {user_id}\n"
+        "schema_version: 1\n"
+        f"last_updated: {timestamp}\n"
+        f"turn_count: {turn_count}\n"
+        "---\n\n"
+        f"{body.strip()}\n"
+    )
+
+
+def _restore_frontmatter(original: str, body: str) -> str:
+    match = _FRONTMATTER_RE.match(original)
+    if match is None:
+        return body
+    return f"{match.group(0).rstrip()}\n\n{body.strip()}\n"
 
 
 @dataclass(frozen=True)
 class UserMemoryState:
     scope_id: str
     text: str
+    load_invocation_stats: tuple[LanguageModelInvocationStats, ...] = ()
 
 
 def _get_model_tokenizer(
@@ -146,6 +185,8 @@ async def condense_user_memory(
     language_model: LanguageModelInfo,
     event: ChatEvent,
     logger: Logger,
+    invocation_stats: list[LanguageModelInvocationStats] | None = None,
+    invocation_source: str = "user_memory_condense",
 ) -> str | None:
     """Ask the LLM to rewrite an oversized profile into a shorter one.
 
@@ -154,7 +195,8 @@ async def condense_user_memory(
     condensed profile, or ``None`` when the call fails or the output does
     not look like a profile (the caller then falls back to a hard cut).
     """
-    current_tokens = count_tokens(content=content, language_model=language_model)
+    body = _profile_body(content)
+    current_tokens = count_tokens(content=body, language_model=language_model)
     target_tokens = max(1, int(max_tokens * _CONDENSE_TARGET_RATIO))
 
     try:
@@ -177,7 +219,7 @@ async def condense_user_memory(
                 )
             ),
             LanguageModelUserMessage(
-                content=condensation_user_prompt(_sanitize_for_xml_context(content))
+                content=condensation_user_prompt(_sanitize_for_xml_context(body))
             ),
         ]
     )
@@ -197,6 +239,15 @@ async def condense_user_memory(
         )
         return None
 
+    if invocation_stats is not None and response.usage is not None:
+        invocation_stats.append(
+            LanguageModelInvocationStats.from_usage(
+                language_model.name,
+                response.usage,
+                source=invocation_source,
+            )
+        )
+
     try:
         raw = response.choices[0].message.content or ""
     except Exception as exc:
@@ -214,7 +265,7 @@ async def condense_user_memory(
         )
         return None
 
-    candidate = _strip_code_fences(raw).strip()
+    candidate = _profile_body(_strip_code_fences(raw))
     if not _is_well_formed_profile(candidate):
         logger.warning(
             "[user-memory] condense output did not look like a profile (%d chars)",
@@ -232,6 +283,8 @@ async def fit_user_memory(
     language_model: LanguageModelInfo,
     event: ChatEvent,
     logger: Logger,
+    invocation_stats: list[LanguageModelInvocationStats] | None = None,
+    invocation_source: str = "user_memory_condense",
 ) -> str:
     """Ensure ``content`` fits ``max_tokens``, condensing before cutting.
 
@@ -257,8 +310,11 @@ async def fit_user_memory(
         language_model=language_model,
         event=event,
         logger=logger,
+        invocation_stats=invocation_stats,
+        invocation_source=invocation_source,
     )
     if condensed is not None:
+        condensed = _restore_frontmatter(content, condensed)
         condensed_tokens = count_tokens(
             content=condensed, language_model=language_model
         )
@@ -321,6 +377,7 @@ async def load_user_memory(
         company_id=company_id,
         logger=logger,
     )
+    invocation_stats: list[LanguageModelInvocationStats] = []
     return UserMemoryState(
         scope_id=scope_id,
         text=await fit_user_memory(
@@ -329,7 +386,10 @@ async def load_user_memory(
             language_model=language_model,
             event=event,
             logger=logger,
+            invocation_stats=invocation_stats,
+            invocation_source="user_memory_load_condense",
         ),
+        load_invocation_stats=tuple(invocation_stats),
     )
 
 
@@ -577,6 +637,7 @@ async def should_consolidate_memory(
     language_model: LanguageModelInfo,
     event: ChatEvent,
     logger: Logger,
+    invocation_stats: list[LanguageModelInvocationStats] | None = None,
 ) -> bool:
     """Cheaply decide whether the turn warrants a full memory rewrite.
 
@@ -627,6 +688,15 @@ async def should_consolidate_memory(
         )
         return True
 
+    if invocation_stats is not None and response.usage is not None:
+        invocation_stats.append(
+            LanguageModelInvocationStats.from_usage(
+                language_model.name,
+                response.usage,
+                source="user_memory_gate",
+            )
+        )
+
     try:
         raw = response.choices[0].message.content or ""
     except Exception as exc:
@@ -665,6 +735,7 @@ async def consolidate_user_memory(
     logger: Logger,
     on_update_start: Callable[[], Awaitable[None]] = noop_update_callback,
     on_update_end: Callable[[], Awaitable[None]] = noop_update_callback,
+    invocation_stats: list[LanguageModelInvocationStats] | None = None,
 ) -> str:
     """Consolidate the latest turn into the user's memory profile.
 
@@ -702,6 +773,7 @@ async def consolidate_user_memory(
         language_model=language_model,
         event=event,
         logger=logger,
+        invocation_stats=invocation_stats,
     ):
         return safe_current
 
@@ -716,6 +788,7 @@ async def consolidate_user_memory(
             language_model=language_model,
             event=event,
             logger=logger,
+            invocation_stats=invocation_stats,
         )
     finally:
         await on_update_end()
@@ -731,6 +804,7 @@ async def _rewrite_user_memory(
     language_model: LanguageModelInfo,
     event: ChatEvent,
     logger: Logger,
+    invocation_stats: list[LanguageModelInvocationStats] | None = None,
 ) -> str:
     if not safe_current.strip():
         safe_current = empty_profile(user_id)
@@ -752,8 +826,7 @@ async def _rewrite_user_memory(
             ),
             LanguageModelUserMessage(
                 content=consolidation_user_prompt(
-                    user_id=user_id,
-                    existing_memory=safe_current,
+                    existing_memory=_profile_body(safe_current),
                     user_message=_sanitize_for_xml_context(user_message or ""),
                     assistant_message=_sanitize_for_xml_context(
                         assistant_message or ""
@@ -780,6 +853,15 @@ async def _rewrite_user_memory(
         )
         return safe_current
 
+    if invocation_stats is not None and response.usage is not None:
+        invocation_stats.append(
+            LanguageModelInvocationStats.from_usage(
+                language_model.name,
+                response.usage,
+                source="user_memory_consolidation",
+            )
+        )
+
     try:
         raw = response.choices[0].message.content or ""
     except Exception as exc:
@@ -801,29 +883,32 @@ async def _rewrite_user_memory(
         logger.info("[user-memory] consolidation NOOP - keeping existing memory")
         return safe_current
 
-    candidate = _strip_code_fences(raw).strip()
-    if not _is_well_formed_profile(candidate):
+    candidate_body = _profile_body(_strip_code_fences(raw))
+    if not _is_well_formed_profile(candidate_body):
         logger.warning(
             "[user-memory] LLM output did not look like a profile (%d chars)",
-            len(candidate),
+            len(candidate_body),
         )
         return safe_current
 
+    if safe_current and candidate_body == _profile_body(safe_current):
+        logger.debug("[user-memory] memory body unchanged - skipping update")
+        return safe_current
+
+    candidate = _assemble_profile(
+        body=candidate_body,
+        user_id=user_id,
+        turn_count=_turn_count(safe_current) + 1,
+    )
     capped = await fit_user_memory(
         content=candidate,
         max_tokens=config.max_tokens,
         language_model=language_model,
         event=event,
         logger=logger,
+        invocation_stats=invocation_stats,
+        invocation_source="user_memory_post_consolidation_condense",
     )
-    if (
-        safe_current
-        and _FRONTMATTER_RE.sub("", capped).strip()
-        == _FRONTMATTER_RE.sub("", safe_current).strip()
-    ):
-        logger.debug("[user-memory] memory body unchanged - skipping update")
-        return safe_current
-
     logger.info(
         "[user-memory] consolidation produced %d tokens (cap=%d)",
         count_tokens(content=capped, language_model=language_model),
@@ -839,9 +924,7 @@ def _sanitize_for_xml_context(text: str) -> str:
 def _is_well_formed_profile(content: str) -> bool:
     if not content or len(content.strip()) < 20:
         return False
-    if _FRONTMATTER_RE.match(content):
-        return True
-    return "## Identity" in content or "# User Memory" in content
+    return content.startswith("# User Memory") and "## Identity" in content
 
 
 def _strip_code_fences(text: str) -> str:

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/unique_user_memory/user_memory_postprocessor.py

@@ -9,6 +9,7 @@ from unique_toolkit.language_model.default_language_model import (
     DEFAULT_LANGUAGE_MODEL,
 )
 from unique_toolkit.language_model.infos import LanguageModelInfo
+from unique_toolkit.language_model.invocation_stats import LanguageModelInvocationStats
 from unique_toolkit.language_model.schemas import LanguageModelStreamResponse
 
 from unique_user_memory.config import UserMemoryConfig
@@ -49,6 +50,28 @@ class UserMemoryPostprocessor(Postprocessor):
         self._logger = logger
         self._new_memory: str | None = None
         self._chat_service: ChatService = chat_service
+        self._pending_load_invocation_stats = list(state.load_invocation_stats)
+        self._invocation_stats: list[LanguageModelInvocationStats] = []
+
+    @property
+    def invocation_stats(self) -> list[LanguageModelInvocationStats]:
+        return list(self._invocation_stats)
+
+    def take_pending_invocation_stats(self) -> list[LanguageModelInvocationStats]:
+        """Pop load-time condense stats not yet reported.
+
+        `UniqueAI` calls this unconditionally at the start of every turn so a
+        turn that exits before `run()` (cancellation, empty response, a
+        control-taking tool) still reports the tokens spent condensing the
+        loaded profile. If `run()` does execute, it drains the same pending
+        list itself, so whichever of the two runs first "wins" and the other
+        sees an empty list -- the tokens are never double-counted or lost.
+        """
+        stats, self._pending_load_invocation_stats = (
+            self._pending_load_invocation_stats,
+            [],
+        )
+        return stats
 
     async def run(self, loop_response: LanguageModelStreamResponse) -> bool:
         """Consolidate and upload user memory for this turn.
@@ -56,6 +79,7 @@ class UserMemoryPostprocessor(Postprocessor):
         Returns True if the memory profile changed and was uploaded, False
         otherwise (no user/company, NOOP consolidation, or failed upload).
         """
+        self._invocation_stats = self.take_pending_invocation_stats()
         self._logger.info("[user-memory] running postprocessor")
         user_id = self._event.user_id
         company_id = self._event.company_id
@@ -99,6 +123,7 @@ class UserMemoryPostprocessor(Postprocessor):
             logger=self._logger,
             on_update_start=on_update_start,
             on_update_end=on_update_end,
+            invocation_stats=self._invocation_stats,
         )
 
         if self._new_memory == self._state.text:

{unique_user_memory-2026.32.0.dev0 → unique_user_memory-2026.32.0.dev2}/unique_user_memory/user_memory_prompts.py

@@ -8,7 +8,7 @@ SECTION_HEADINGS: tuple[str, ...] = (
     "Work Context",
     "Skills & Expertise",
     "Recent Topics",
-    "Open Questions / Follow-ups",
+    "Follow-ups",
 )
 
 _EMPTY_PROFILE_TEMPLATE = """\
@@ -52,16 +52,16 @@ small mistakes in extraction compound across every future conversation.
 
 You receive two XML blocks:
 
-1. `<existing_memory>` - the current profile file (Markdown, with YAML
-   frontmatter). May be empty on the user's first turn.
+1. `<existing_memory>` - the current Markdown profile body. May be empty
+   on the user's first turn.
 2. `<new_turn>` - the most recent user message and the assistant's
    reply, prefixed with `user:` and `assistant:`.
 
 # Output
 
-Return the complete, rewritten profile file as Markdown - frontmatter
-followed by the body. Do NOT emit a diff. Do NOT wrap the output in
-``` fences. Do NOT add commentary before or after the file.
+Return the complete, rewritten Markdown profile body, starting with
+`# User Memory`. Do NOT emit a diff. Do NOT wrap the output in
+``` fences. Do NOT add commentary before or after the body.
 
 The body MUST contain exactly these section headings, in this order, even
 when a section is empty (use the literal string `_(empty)_` as a placeholder):
@@ -119,8 +119,8 @@ ADD/UPDATE for facts that are:
   tone, language, expertise level, examples preferred over theory.
 - Contextual but durable - current focus areas, active projects,
   multi-week goals, deadlines mentioned by the user.
-- Hand-offs - explicit "let's revisit X later", "remind me about
-  Y", "I'll come back to Z" go into "Open Questions / Follow-ups".
+- Follow-ups - concrete tasks the user intends to complete in the future,
+  or tasks they explicitly ask to be reminded about.
 
 NEVER extract:
 
@@ -135,11 +135,11 @@ NEVER extract:
 
 # Word budget - STRICT
 
-The complete file MUST be <= {{ max_words }} words (corresponding to {{ max_tokens }} tokens).
+The complete body MUST be <= {{ max_words }} words (corresponding to {{ max_tokens }} tokens).
 When approaching the budget, drop content in this priority order:
 
 1. Oldest entries in Recent Topics.
-2. Resolved or stale entries in Open Questions / Follow-ups.
+2. Completed, cancelled, or stale entries in Follow-ups.
 3. Fold low-signal Work Context bullets into a one-line summary.
 4. Fold low-signal Skills & Expertise bullets into broader categories.
 5. Identity and Communication Preferences - never drop, only tighten.
@@ -148,14 +148,6 @@ When approaching the budget, drop content in this priority order:
 
 The current UTC date and time is **{{ now_datetime }}**. You do NOT know the date from any other source - always use this supplied value. Never guess or infer the date.
 
-# Frontmatter rules
-
-- Preserve `user_id` and `schema_version` from `<existing_memory>` exactly.
-- Set `last_updated` to the supplied current UTC timestamp ({{ now_datetime }}).
-- Increment `turn_count` by 1.
-- If `<existing_memory>` is empty, initialize with `schema_version: 1`,
-  `turn_count: 1`, and the user_id supplied in the user message.
-
 # Style
 
 - Use `-` markdown bullets, no nesting beyond two levels.
@@ -180,8 +172,8 @@ def consolidation_system_prompt(max_tokens: int) -> str:
 _CONDENSATION_SYSTEM_PROMPT_TEMPLATE = """\
 You are a memory-compaction engine for the Unique AI platform.
 
-You are given an existing user-memory profile (Markdown with YAML
-frontmatter) that is OVER its size budget. Your job is to rewrite it so
+You are given an existing user-memory Markdown body that is OVER its
+size budget. Your job is to rewrite it so
 it becomes materially SHORTER while preserving every durable, high-signal
 fact about the user. This is lossy compression, not deletion of meaning.
 
@@ -198,8 +190,8 @@ fact about the user. This is lossy compression, not deletion of meaning.
    overlapping information into a single clear bullet. Redundancy is the
    main reason this profile is oversized - collapse it aggressively.
 2. Delete outdated, stale, resolved, or superseded entries: old
-   "Recent Topics", answered "Open Questions / Follow-ups", and facts a
-   later bullet already contradicts or refines.
+   "Recent Topics", completed or cancelled "Follow-ups", and facts a later
+   bullet already contradicts or refines.
 3. Tighten verbose, flowery, or repetitive prose into short factual
    bullets. Remove hedging and filler.
 4. Fold low-signal "Work Context" and "Skills & Expertise" bullets into
@@ -211,8 +203,6 @@ fact about the user. This is lossy compression, not deletion of meaning.
 # Hard rules
 
 - NEVER invent, embellish, or add facts that are not already present.
-- Preserve the YAML frontmatter. Keep `user_id` and `schema_version`
-  exactly; keep `last_updated` and `turn_count` as they are.
 - Keep exactly these section headings, in this order, even if a section
   becomes empty (use the literal string `_(empty)_`):
 
@@ -224,9 +214,9 @@ fact about the user. This is lossy compression, not deletion of meaning.
 
 # Output
 
-Return ONLY the complete rewritten profile file - frontmatter followed by
-the body. Do NOT emit a diff, do NOT wrap the output in ``` fences, and
-do NOT add any commentary before or after the file.
+Return the complete rewritten profile body, starting with
+`# User Memory`. Do NOT emit a diff, or commentary,
+and do NOT wrap the output in ``` fences.
 """
 
 
@@ -254,7 +244,7 @@ _CONDENSATION_USER_PROMPT_TEMPLATE = """\
 {{ profile }}
 </profile_to_condense>
 
-Return the complete, condensed profile file now.
+Return the complete, condensed profile body now.
 """
 
 
@@ -263,8 +253,6 @@ def condensation_user_prompt(profile: str) -> str:
 
 
 _CONSOLIDATION_USER_PROMPT_TEMPLATE = """\
-User ID: {{ user_id }}
-
 <existing_memory>
 {{ existing_memory }}
 </existing_memory>
@@ -274,19 +262,17 @@ user: {{ user_message }}
 assistant: {{ assistant_message }}
 </new_turn>
 
-Return the complete rewritten profile file now.
+Return the complete rewritten profile body now.
 """
 
 
 def consolidation_user_prompt(
-    user_id: str,
     existing_memory: str,
     user_message: str,
     assistant_message: str,
 ) -> str:
     existing = existing_memory.strip() or "(empty - this is the user's first turn)"
     return Template(_CONSOLIDATION_USER_PROMPT_TEMPLATE).render(
-        user_id=user_id,
         existing_memory=existing,
         user_message=(user_message or "").strip(),
         assistant_message=(assistant_message or "").strip(),
@@ -327,7 +313,8 @@ only the single word `UPDATE` or `NOOP`.
   expertise level.
 - Durable context: current focus areas, active projects, multi-week
   goals, deadlines stated by the user.
-- Explicit hand-offs: "remind me about X", "let's revisit Y later".
+- Concrete future tasks the user intends to complete or explicitly asks
+  to be reminded about.
 
 # What NEVER justifies UPDATE (lean NOOP)