unique-user-memory 2026.28.0.dev4__tar.gz → 2026.28.0.dev6__tar.gz

unique_user_memory-2026.28.0.dev4/README.md → unique_user_memory-2026.28.0.dev6/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.3
+Name: unique-user-memory
+Version: 2026.28.0.dev6
+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.28.0.dev15,<2026.28.0rc0
+Requires-Dist: unique-toolkit>=2026.28.0.dev14,<2026.28.0rc0
+Requires-Python: >=3.12, <4
+Description-Content-Type: text/markdown
+
 # Unique User Memory
 
 Persistent per-user memory for Unique AI agents.
@@ -9,7 +23,7 @@ Persistent per-user memory for Unique AI agents.
 The package provides:
 
 - `UserMemoryConfig` - Pydantic configuration for the consolidation model, profile token budget, and memory folder.
-- `load_user_memory(...)` - resolves the user's private memory folder, downloads `memory.md`, and enforces the configured token budget.
+- `load_user_memory(...)` - resolves the user's private memory folder, downloads `memory.md`, and enforces the configured token budget. The `language_model` argument is used to tokenize `memory.md` when capping it, so it must be the same effective model the postprocessor uses for consolidation (see Integration below).
 - `UserMemoryPostprocessor` - runs after the assistant response, consolidates the latest turn into the profile, and uploads the updated `memory.md`.
 
 The memory file is intentionally small and structured. It is rewritten as a full Markdown profile rather than appended to as an event log.
@@ -83,21 +97,35 @@ config = UserMemoryConfig(
 
 | Field | Default | Description |
 | --- | --- | --- |
-| `language_model` | `DEFAULT_GPT_4o` | Model used to consolidate the latest turn into the profile. |
+| `use_orchestrator_language_model` | `True` | When true, consolidation and load-time token capping use the model the orchestrator passes in and `language_model` is ignored. Set to `False` to use the configured `language_model` for both. |
+| `language_model` | `DEFAULT_GPT_4o` | Model used to consolidate the latest turn and to tokenize `memory.md` at load time when `use_orchestrator_language_model` is `False`. |
 | `max_tokens` | `2000` | Maximum profile size. Must be between 500 and 8000 tokens. |
 | `root_folder` | `user-memory` | Root KB folder that contains per-user memory folders. |
 
 ## Integration
 
-Typical orchestration code loads memory before the agent loop and registers the postprocessor for the same turn:
+Typical orchestration code loads memory before the agent loop and registers the postprocessor for the same turn.
+
+`load_user_memory` and `UserMemoryPostprocessor` must be given the **same** effective language model: the postprocessor consolidates memory with either the orchestrator model or the configured one depending on `use_orchestrator_language_model`, and load-time token capping must use that same model so the loaded baseline is tokenized the way consolidation expects. Resolve the effective model once and pass it to both:
 
 ```python
 from unique_user_memory.user_memory import load_user_memory
 from unique_user_memory.user_memory_postprocessor import UserMemoryPostprocessor
 
+user_memory_config = config.agent.services.user_memory_config
+
+# Resolve the effective model once and reuse it for load-time capping and
+# consolidation so both use the same tokenizer.
+memory_language_model = (
+    config.space.language_model
+    if user_memory_config.use_orchestrator_language_model
+    else user_memory_config.language_model
+)
+
 user_memory_state = await load_user_memory(
     event=event,
-    config=config.agent.services.user_memory_config,
+    config=user_memory_config,
+    language_model=memory_language_model,
     logger=logger,
 )
 
@@ -105,10 +133,13 @@ if user_memory_state is not None:
     user_memory_text = user_memory_state.text
     postprocessor_manager.add_postprocessor(
         UserMemoryPostprocessor(
-            config=config.agent.services.user_memory_config,
+            config=user_memory_config,
+            language_model=memory_language_model,
             event=event,
             state=user_memory_state,
             logger=logger,
         )
     )
 ```
+
+Note that `UserMemoryPostprocessor` re-derives the effective model internally from `use_orchestrator_language_model`, so passing `memory_language_model` (rather than the raw orchestrator model) keeps its behavior identical while ensuring `load_user_memory` caps with the matching tokenizer.

unique_user_memory-2026.28.0.dev4/PKG-INFO → unique_user_memory-2026.28.0.dev6/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.3
-Name: unique-user-memory
-Version: 2026.28.0.dev4
-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.28.0.dev8,<2026.28.0rc0
-Requires-Dist: unique-toolkit>=2026.28.0.dev6,<2026.28.0rc0
-Requires-Python: >=3.12, <4
-Description-Content-Type: text/markdown
-
 # Unique User Memory
 
 Persistent per-user memory for Unique AI agents.
@@ -23,7 +9,7 @@ Persistent per-user memory for Unique AI agents.
 The package provides:
 
 - `UserMemoryConfig` - Pydantic configuration for the consolidation model, profile token budget, and memory folder.
-- `load_user_memory(...)` - resolves the user's private memory folder, downloads `memory.md`, and enforces the configured token budget.
+- `load_user_memory(...)` - resolves the user's private memory folder, downloads `memory.md`, and enforces the configured token budget. The `language_model` argument is used to tokenize `memory.md` when capping it, so it must be the same effective model the postprocessor uses for consolidation (see Integration below).
 - `UserMemoryPostprocessor` - runs after the assistant response, consolidates the latest turn into the profile, and uploads the updated `memory.md`.
 
 The memory file is intentionally small and structured. It is rewritten as a full Markdown profile rather than appended to as an event log.
@@ -97,21 +83,35 @@ config = UserMemoryConfig(
 
 | Field | Default | Description |
 | --- | --- | --- |
-| `language_model` | `DEFAULT_GPT_4o` | Model used to consolidate the latest turn into the profile. |
+| `use_orchestrator_language_model` | `True` | When true, consolidation and load-time token capping use the model the orchestrator passes in and `language_model` is ignored. Set to `False` to use the configured `language_model` for both. |
+| `language_model` | `DEFAULT_GPT_4o` | Model used to consolidate the latest turn and to tokenize `memory.md` at load time when `use_orchestrator_language_model` is `False`. |
 | `max_tokens` | `2000` | Maximum profile size. Must be between 500 and 8000 tokens. |
 | `root_folder` | `user-memory` | Root KB folder that contains per-user memory folders. |
 
 ## Integration
 
-Typical orchestration code loads memory before the agent loop and registers the postprocessor for the same turn:
+Typical orchestration code loads memory before the agent loop and registers the postprocessor for the same turn.
+
+`load_user_memory` and `UserMemoryPostprocessor` must be given the **same** effective language model: the postprocessor consolidates memory with either the orchestrator model or the configured one depending on `use_orchestrator_language_model`, and load-time token capping must use that same model so the loaded baseline is tokenized the way consolidation expects. Resolve the effective model once and pass it to both:
 
 ```python
 from unique_user_memory.user_memory import load_user_memory
 from unique_user_memory.user_memory_postprocessor import UserMemoryPostprocessor
 
+user_memory_config = config.agent.services.user_memory_config
+
+# Resolve the effective model once and reuse it for load-time capping and
+# consolidation so both use the same tokenizer.
+memory_language_model = (
+    config.space.language_model
+    if user_memory_config.use_orchestrator_language_model
+    else user_memory_config.language_model
+)
+
 user_memory_state = await load_user_memory(
     event=event,
-    config=config.agent.services.user_memory_config,
+    config=user_memory_config,
+    language_model=memory_language_model,
     logger=logger,
 )
 
@@ -119,10 +119,13 @@ if user_memory_state is not None:
     user_memory_text = user_memory_state.text
     postprocessor_manager.add_postprocessor(
         UserMemoryPostprocessor(
-            config=config.agent.services.user_memory_config,
+            config=user_memory_config,
+            language_model=memory_language_model,
             event=event,
             state=user_memory_state,
             logger=logger,
         )
     )
 ```
+
+Note that `UserMemoryPostprocessor` re-derives the effective model internally from `use_orchestrator_language_model`, so passing `memory_language_model` (rather than the raw orchestrator model) keeps its behavior identical while ensuring `load_user_memory` caps with the matching tokenizer.

{unique_user_memory-2026.28.0.dev4 → unique_user_memory-2026.28.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_user_memory"
-version = "2026.28.0.dev4"
+version = "2026.28.0.dev6"
 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.28.0.dev8,<2026.28.0rc0",
-    "unique-toolkit>=2026.28.0.dev6,<2026.28.0rc0",
+    "unique-sdk>=2026.28.0.dev15,<2026.28.0rc0",
+    "unique-toolkit>=2026.28.0.dev14,<2026.28.0rc0",
 ]
 
 [dependency-groups]

{unique_user_memory-2026.28.0.dev4 → unique_user_memory-2026.28.0.dev6}/unique_user_memory/config.py

@@ -4,16 +4,29 @@ from pydantic import BaseModel, Field
 from unique_toolkit._common.pydantic.rjsf_tags import RJSFMetaTag
 from unique_toolkit._common.validators import LMI
 from unique_toolkit.agentic.tools.config import get_configuration_dict
-from unique_toolkit.language_model.default_language_model import DEFAULT_GPT_4o
+from unique_toolkit.language_model.default_language_model import (
+    DEFAULT_LANGUAGE_MODEL,
+)
 from unique_toolkit.language_model.infos import LanguageModelInfo
 
 
 class UserMemoryConfig(BaseModel):
     model_config = get_configuration_dict()
 
+    use_orchestrator_language_model: bool = Field(
+        default=True,
+        description=(
+            "When true, post-turn memory consolidation uses the orchestrator's "
+            "language model and the configured 'language_model' is ignored. "
+            "When false, the configured 'language_model' is used."
+        ),
+    )
     language_model: LMI = Field(
-        default=LanguageModelInfo.from_name(DEFAULT_GPT_4o),
-        description="The language model used for post-turn memory consolidation.",
+        default=LanguageModelInfo.from_name(DEFAULT_LANGUAGE_MODEL),
+        description=(
+            "The language model used for post-turn memory consolidation when "
+            "'Use Orchestrator Language Model' is false."
+        ),
     )
     max_tokens: int = Field(
         default=2000,

{unique_user_memory-2026.28.0.dev4 → unique_user_memory-2026.28.0.dev6}/unique_user_memory/tests/test_user_memory.py

@@ -1,21 +1,29 @@
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
+from unique_toolkit.language_model.default_language_model import (
+    DEFAULT_LANGUAGE_MODEL,
+)
+from unique_toolkit.language_model.infos import LanguageModelInfo
 
 from unique_user_memory.config import UserMemoryConfig
 from unique_user_memory.user_memory import (
     UserMemoryState,
     _sanitize_for_xml_context,
+    condense_user_memory,
     consolidate_user_memory,
     count_tokens,
     download_user_memory,
     enforce_token_cap,
     ensure_user_memory_folder,
+    fit_user_memory,
     upload_user_memory,
 )
 from unique_user_memory.user_memory_postprocessor import UserMemoryPostprocessor
 from unique_user_memory.user_memory_prompts import empty_profile
 
+_TEST_LANGUAGE_MODEL = LanguageModelInfo.from_name(DEFAULT_LANGUAGE_MODEL)
+
 
 def test_enforce_token_cap_truncates_long_content() -> None:
     content = "\n\n".join(f"paragraph {index} " + "word " * 40 for index in range(50))
@@ -26,6 +34,113 @@ def test_enforce_token_cap_truncates_long_content() -> None:
     assert len(capped) < len(content)
 
 
+def test_enforce_token_cap_keeps_body_when_section_exceeds_budget() -> None:
+    # A single section whose bullets are joined by single newlines used to be
+    # treated as one indivisible paragraph, dropping the whole body.
+    bullets = "\n".join(f"- fact number {index} about the user" for index in range(200))
+    content = f"# User Memory\n\n## Identity\n{bullets}"
+
+    capped = enforce_token_cap(content=content, max_tokens=120)
+
+    assert "<!-- truncated to fit memory budget -->" in capped
+    assert "# User Memory" in capped
+    assert "## Identity" in capped
+    # Some individual bullets survive rather than only the heading.
+    assert "- fact number 0 about the user" in capped
+    assert count_tokens(content=capped) <= 120
+
+
+@pytest.mark.asyncio
+async def test_fit_user_memory_returns_unchanged_when_within_budget() -> None:
+    content = "# User Memory\n\n## Identity\n- short"
+
+    result = await fit_user_memory(
+        content=content,
+        max_tokens=2000,
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=MagicMock(),
+        logger=MagicMock(),
+    )
+
+    assert result == content
+
+
+@pytest.mark.asyncio
+async def test_fit_user_memory_condenses_before_hard_cut(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    oversized = "# User Memory\n\n## Identity\n" + "\n".join(
+        f"- fact number {index} that is fairly wordy about the user"
+        for index in range(400)
+    )
+    condensed = "# User Memory\n\n## Identity\n- concise summary of the user"
+    condense = AsyncMock(return_value=condensed)
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.condense_user_memory",
+        condense,
+    )
+
+    result = await fit_user_memory(
+        content=oversized,
+        max_tokens=120,
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=MagicMock(),
+        logger=MagicMock(),
+    )
+
+    assert result == condensed
+    condense.assert_awaited_once()
+    assert "<!-- truncated to fit memory budget -->" not in result
+
+
+@pytest.mark.asyncio
+async def test_fit_user_memory_hard_cuts_when_condense_fails(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    oversized = "# User Memory\n\n## Identity\n" + "\n".join(
+        f"- fact number {index} about the user" for index in range(400)
+    )
+    monkeypatch.setattr(
+        "unique_user_memory.user_memory.condense_user_memory",
+        AsyncMock(return_value=None),
+    )
+
+    result = await fit_user_memory(
+        content=oversized,
+        max_tokens=120,
+        language_model=_TEST_LANGUAGE_MODEL,
+        event=MagicMock(),
+        logger=MagicMock(),
+    )
+
+    assert "<!-- truncated to fit memory budget -->" in result
+    assert count_tokens(content=result) <= 120
+
+
+@pytest.mark.asyncio
+async def test_condense_user_memory_rejects_non_profile_output(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    response = MagicMock()
+    response.choices[0].message.content = "sorry, I cannot help"
+    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 is None
+
+
 def test_count_tokens_uses_language_model_encoder() -> None:
     language_model = MagicMock()
     language_model.get_encoder.return_value = lambda content: content.split()
@@ -58,6 +173,7 @@ async def test_consolidate_user_memory_keeps_existing_on_noop(
         user_message="hello",
         assistant_message="hi",
         config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
         event=MagicMock(),
         logger=MagicMock(),
     )
@@ -85,6 +201,7 @@ async def test_consolidate_user_memory_keeps_existing_on_malformed_output(
         user_message="remember I like concise answers",
         assistant_message="noted",
         config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
         event=MagicMock(),
         logger=MagicMock(),
     )
@@ -381,6 +498,7 @@ async def test_user_memory_postprocessor_logs_success_when_upload_succeeds(
     logger = MagicMock()
     postprocessor = UserMemoryPostprocessor(
         config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
         event=event,
         state=UserMemoryState(scope_id="scope_1", text=empty_profile("user_1")),
         logger=logger,
@@ -422,6 +540,7 @@ async def test_user_memory_postprocessor_does_not_log_success_when_upload_fails(
     logger = MagicMock()
     postprocessor = UserMemoryPostprocessor(
         config=UserMemoryConfig(),
+        language_model=_TEST_LANGUAGE_MODEL,
         event=event,
         state=UserMemoryState(scope_id="scope_1", text=empty_profile("user_1")),
         logger=logger,

{unique_user_memory-2026.28.0.dev4 → unique_user_memory-2026.28.0.dev6}/unique_user_memory/user_memory.py

@@ -23,6 +23,8 @@ from unique_toolkit.language_model.infos import LanguageModelInfo
 from unique_user_memory.config import UserMemoryConfig
 from unique_user_memory.user_memory_prompts import (
     SECTION_HEADINGS,
+    condensation_system_prompt,
+    condensation_user_prompt,
     consolidation_system_prompt,
     consolidation_user_prompt,
     empty_profile,
@@ -31,6 +33,9 @@ from unique_user_memory.user_memory_prompts import (
 MEMORY_FILENAME = "memory.md"
 MIME_TYPE = "text/markdown"
 _LLM_OUTPUT_HEADROOM_TOKENS = 200
+# When condensing an oversized profile, aim below the hard cap so the LLM
+# output leaves headroom and the hard-cut safety net rarely has to fire.
+_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)
@@ -85,18 +90,22 @@ def enforce_token_cap(
 
     marker_tokens = _count_tokens(content=_TRUNCATION_MARKER, encode=encode)
     target = max(0, max_tokens - marker_tokens)
-    paragraphs = content.split("\n\n")
+    # Split on lines rather than blank-line paragraphs: memory profiles keep
+    # each bullet on its own line inside a section, so paragraph-level cuts
+    # would treat a whole (multi-thousand-token) section as one indivisible
+    # unit and drop the entire body once it exceeds the budget.
+    lines = content.split("\n")
     accepted: list[str] = []
     running = 0
-    for paragraph in paragraphs:
-        paragraph_tokens = _count_tokens(content=paragraph + "\n\n", encode=encode)
-        if running + paragraph_tokens > target:
+    for line in lines:
+        line_tokens = _count_tokens(content=line + "\n", encode=encode)
+        if running + line_tokens > target:
             break
-        accepted.append(paragraph)
-        running += paragraph_tokens
+        accepted.append(line)
+        running += line_tokens
 
     if accepted:
-        truncated = "\n\n".join(accepted)
+        truncated = "\n".join(accepted)
     else:
         truncated = decode(encode(content)[:target])
 
@@ -113,10 +122,164 @@ def enforce_token_cap(
     return result
 
 
+async def condense_user_memory(
+    *,
+    content: str,
+    max_tokens: int,
+    language_model: LanguageModelInfo,
+    event: ChatEvent,
+    logger: Logger,
+) -> str | None:
+    """Ask the LLM to rewrite an oversized profile into a shorter one.
+
+    Removes duplicate and outdated bullets and tightens prose, targeting a
+    fraction of the hard cap so the result leaves headroom. Returns the
+    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)
+    target_tokens = max(1, int(max_tokens * _CONDENSE_TARGET_RATIO))
+
+    try:
+        llm_service = LanguageModelService(event)
+    except Exception as exc:
+        logger.warning(
+            "[user-memory] cannot construct LanguageModelService for condense: [%s] %s",
+            type(exc).__name__,
+            exc,
+        )
+        return None
+
+    messages = LanguageModelMessages(
+        [
+            LanguageModelSystemMessage(
+                content=condensation_system_prompt(
+                    max_tokens=max_tokens,
+                    current_tokens=current_tokens,
+                    target_tokens=target_tokens,
+                )
+            ),
+            LanguageModelUserMessage(
+                content=condensation_user_prompt(_sanitize_for_xml_context(content))
+            ),
+        ]
+    )
+
+    try:
+        response = await llm_service.complete_async(
+            messages=messages,
+            model_name=language_model.name,
+            other_options={"max_tokens": max_tokens + _LLM_OUTPUT_HEADROOM_TOKENS},
+        )
+    except Exception as exc:
+        logger.warning(
+            "[user-memory] condense LLM call failed (model=%s): [%s] %s",
+            language_model.name,
+            type(exc).__name__,
+            exc,
+        )
+        return None
+
+    try:
+        raw = response.choices[0].message.content or ""
+    except Exception as exc:
+        logger.warning(
+            "[user-memory] could not extract content from condense response: [%s] %s",
+            type(exc).__name__,
+            exc,
+        )
+        return None
+
+    if not isinstance(raw, str):
+        logger.warning(
+            "[user-memory] condense returned non-string content (%s)",
+            type(raw).__name__,
+        )
+        return None
+
+    candidate = _strip_code_fences(raw).strip()
+    if not _is_well_formed_profile(candidate):
+        logger.warning(
+            "[user-memory] condense output did not look like a profile (%d chars)",
+            len(candidate),
+        )
+        return None
+
+    return candidate
+
+
+async def fit_user_memory(
+    *,
+    content: str,
+    max_tokens: int,
+    language_model: LanguageModelInfo,
+    event: ChatEvent,
+    logger: Logger,
+) -> str:
+    """Ensure ``content`` fits ``max_tokens``, condensing before cutting.
+
+    Fast path: content already within budget is returned untouched (no LLM
+    call). Otherwise the profile is first condensed by the LLM, and only a
+    still-oversized result is hard-cut by :func:`enforce_token_cap`.
+    """
+    if not content:
+        return content
+
+    if count_tokens(content=content, language_model=language_model) <= max_tokens:
+        return content
+
+    current_tokens = count_tokens(content=content, language_model=language_model)
+    logger.info(
+        "[user-memory] memory over budget (%d > %d tokens) - condensing via LLM",
+        current_tokens,
+        max_tokens,
+    )
+    condensed = await condense_user_memory(
+        content=content,
+        max_tokens=max_tokens,
+        language_model=language_model,
+        event=event,
+        logger=logger,
+    )
+    if condensed is not None:
+        condensed_tokens = count_tokens(
+            content=condensed, language_model=language_model
+        )
+        if condensed_tokens <= max_tokens:
+            logger.info(
+                "[user-memory] memory condensed from %d to %d tokens (cap=%d)",
+                current_tokens,
+                condensed_tokens,
+                max_tokens,
+            )
+            return condensed
+        logger.info(
+            "[user-memory] still over budget after condense (%d > %d) - "
+            "applying hard cut",
+            condensed_tokens,
+            max_tokens,
+        )
+        content = condensed
+
+    result = enforce_token_cap(
+        content=content,
+        max_tokens=max_tokens,
+        language_model=language_model,
+    )
+    logger.info(
+        "[user-memory] memory condensed from %d to %d tokens (cap=%d)",
+        current_tokens,
+        count_tokens(content=result, language_model=language_model),
+        max_tokens,
+    )
+    return result
+
+
 async def load_user_memory(
     *,
     event: ChatEvent,
     config: UserMemoryConfig,
+    language_model: LanguageModelInfo,
     logger: Logger,
 ) -> UserMemoryState | None:
     user_id = event.user_id
@@ -143,10 +306,12 @@ async def load_user_memory(
     )
     return UserMemoryState(
         scope_id=scope_id,
-        text=enforce_token_cap(
+        text=await fit_user_memory(
             content=text,
             max_tokens=config.max_tokens,
-            language_model=config.language_model,
+            language_model=language_model,
+            event=event,
+            logger=logger,
         ),
     )
 
@@ -393,18 +558,19 @@ async def consolidate_user_memory(
     user_message: str,
     assistant_message: str,
     config: UserMemoryConfig,
+    language_model: LanguageModelInfo,
     event: ChatEvent,
     logger: Logger,
 ) -> str:
     safe_current = enforce_token_cap(
         content=current_memory,
         max_tokens=config.max_tokens,
-        language_model=config.language_model,
+        language_model=language_model,
     )
     logger.info(
         "[user-memory] consolidating turn - existing_memory_tokens=%d | "
         "user_msg_chars=%d | assistant_msg_chars=%d",
-        count_tokens(content=safe_current, language_model=config.language_model),
+        count_tokens(content=safe_current, language_model=language_model),
         len(user_message or ""),
         len(assistant_message or ""),
     )
@@ -413,7 +579,7 @@ async def consolidate_user_memory(
         return safe_current or enforce_token_cap(
             content=empty_profile(user_id),
             max_tokens=config.max_tokens,
-            language_model=config.language_model,
+            language_model=language_model,
         )
 
     if not safe_current.strip():
@@ -450,7 +616,7 @@ async def consolidate_user_memory(
     try:
         response = await llm_service.complete_async(
             messages=messages,
-            model_name=config.language_model.name,
+            model_name=language_model.name,
             other_options={
                 "max_tokens": config.max_tokens + _LLM_OUTPUT_HEADROOM_TOKENS,
             },
@@ -458,7 +624,7 @@ async def consolidate_user_memory(
     except Exception as exc:
         logger.warning(
             "[user-memory] consolidation LLM call failed (model=%s): [%s] %s",
-            config.language_model.name,
+            language_model.name,
             type(exc).__name__,
             exc,
         )
@@ -493,10 +659,12 @@ async def consolidate_user_memory(
         )
         return safe_current
 
-    capped = enforce_token_cap(
+    capped = await fit_user_memory(
         content=candidate,
         max_tokens=config.max_tokens,
-        language_model=config.language_model,
+        language_model=language_model,
+        event=event,
+        logger=logger,
     )
     if (
         safe_current
@@ -508,7 +676,7 @@ async def consolidate_user_memory(
 
     logger.info(
         "[user-memory] consolidation produced %d tokens (cap=%d)",
-        count_tokens(content=capped, language_model=config.language_model),
+        count_tokens(content=capped, language_model=language_model),
         config.max_tokens,
     )
     return capped

{unique_user_memory-2026.28.0.dev4 → unique_user_memory-2026.28.0.dev6}/unique_user_memory/user_memory_postprocessor.py

@@ -2,6 +2,10 @@ from logging import Logger
 
 from unique_toolkit.agentic.postprocessor.postprocessor_manager import Postprocessor
 from unique_toolkit.app.schemas import ChatEvent
+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.schemas import LanguageModelStreamResponse
 
 from unique_user_memory.config import UserMemoryConfig
@@ -17,12 +21,20 @@ class UserMemoryPostprocessor(Postprocessor):
         self,
         *,
         config: UserMemoryConfig,
+        language_model: LanguageModelInfo = LanguageModelInfo.from_name(
+            DEFAULT_LANGUAGE_MODEL
+        ),
         event: ChatEvent,
         state: UserMemoryState,
         logger: Logger,
     ) -> None:
         super().__init__(name="UserMemoryPostprocessor")
         self._config = config
+        self._language_model = (
+            language_model
+            if config.use_orchestrator_language_model
+            else config.language_model
+        )
         self._event = event
         self._state = state
         self._logger = logger
@@ -41,6 +53,7 @@ class UserMemoryPostprocessor(Postprocessor):
             user_message=self._event.payload.user_message.text or "",
             assistant_message=loop_response.message.text or "",
             config=self._config,
+            language_model=self._language_model,
             event=self._event,
             logger=self._logger,
         )

{unique_user_memory-2026.28.0.dev4 → unique_user_memory-2026.28.0.dev6}/unique_user_memory/user_memory_prompts.py

@@ -75,8 +75,10 @@ For each candidate fact in `<new_turn>`, decide one of:
 - ADD - the fact is new and stable enough to remember (preferences,
   identity attributes, ongoing projects, skills, dated topics). Add it as
   a bullet in the most appropriate section.
-- UPDATE - the fact refines or supersedes an existing bullet. Edit
-  the existing bullet in place; do not add a duplicate.
+- UPDATE - the fact refines, supersedes, or contradicts an existing
+  bullet. Overwrite the existing bullet in place with the new
+  information; do not add a duplicate and do not keep the old version
+  alongside the new one.
 - DELETE - the new turn explicitly contradicts or invalidates an
   existing bullet that is not worth keeping as history. Remove it.
 - NOOP - the new turn contains no facts about the user (small talk,
@@ -87,6 +89,26 @@ For each candidate fact in `<new_turn>`, decide one of:
 Prefer UPDATE over ADD when in doubt - duplication is the most common
 failure mode of memory systems.
 
+# Resolving contradictions - ALWAYS
+
+When a new statement contradicts an existing bullet (a changed
+preference, a corrected fact, an updated status), the new statement
+always wins. Overwrite the old bullet with the new information and
+remove the outdated version. Two contradictory bullets must never
+coexist in the profile - for example, do not keep both "Prefers all
+responses in German" and "Prefers responses in English". Resolve the
+conflict decisively in favour of the most recent statement, even when
+the older bullet is in a different position or worded differently.
+
+# Consolidating within sections - ALWAYS
+
+Sections tend to grow with bullets that state the same or overlapping
+information in different words. Before returning the profile, review
+each section and merge bullets that are duplicates or semantically
+similar (same meaning, different wording) into a single clear bullet.
+A section must never accumulate redundant or near-duplicate statements.
+Consolidate on every turn, not only when approaching the word budget.
+
 # What to extract
 
 ADD/UPDATE for facts that are:
@@ -155,6 +177,91 @@ 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
+it becomes materially SHORTER while preserving every durable, high-signal
+fact about the user. This is lossy compression, not deletion of meaning.
+
+# Size target - STRICT
+
+- The current profile is about {{ current_tokens }} tokens.
+- You MUST bring it down to at most {{ target_tokens }} tokens
+  (roughly {{ target_words }} words) - about a {{ reduction_pct }}%
+  reduction. Aim comfortably under the target; do not stop early.
+
+# How to shrink (in priority order)
+
+1. Merge duplicate and near-duplicate bullets that state the same or
+   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.
+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
+   broader summary bullets.
+5. "Identity" and "Communication Preferences" carry the most durable
+   signal - tighten and de-duplicate them, but never drop a genuinely
+   distinct fact or preference.
+
+# 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)_`):
+
+{{ section_list }}
+
+- Resolve contradictions in favour of the most recent statement; never
+  keep two conflicting bullets.
+- Use `-` markdown bullets, no nesting beyond two levels, no emojis.
+
+# 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.
+"""
+
+
+def condensation_system_prompt(
+    *,
+    max_tokens: int,
+    current_tokens: int,
+    target_tokens: int,
+) -> str:
+    section_list = "\n".join(f"- ## {heading}" for heading in SECTION_HEADINGS)
+    safe_current = max(current_tokens, target_tokens + 1)
+    reduction_pct = int(round((1 - target_tokens / safe_current) * 100))
+    return Template(_CONDENSATION_SYSTEM_PROMPT_TEMPLATE).render(
+        section_list=section_list,
+        current_tokens=current_tokens,
+        target_tokens=target_tokens,
+        target_words=int(target_tokens * 0.75),
+        reduction_pct=max(reduction_pct, 1),
+        max_tokens=max_tokens,
+    )
+
+
+_CONDENSATION_USER_PROMPT_TEMPLATE = """\
+<profile_to_condense>
+{{ profile }}
+</profile_to_condense>
+
+Return the complete, condensed profile file now.
+"""
+
+
+def condensation_user_prompt(profile: str) -> str:
+    return Template(_CONDENSATION_USER_PROMPT_TEMPLATE).render(profile=profile)
+
+
 _CONSOLIDATION_USER_PROMPT_TEMPLATE = """\
 User ID: {{ user_id }}