superlocalmemory 4.0.7 → 4.0.8

package/src/superlocalmemory/server/routes/memories.py

@@ -747,6 +747,159 @@ async def search_memories(request: Request, body: SearchRequest):
         end_recall()
 
 
+@router.get("/api/summary")
+async def get_summary(request: Request, kind: str = "day", target: str = ""):
+    """Readable summary of memories: a day, a project, or one session (#113).
+
+    The dashboard surface for the summary layer. 4.0.6 shipped the generators
+    with no caller, 4.0.7 added the CLI, 4.0.8 adds this and the MCP tool — the
+    "no command, tool or endpoint" gap, closed at the third point.
+
+    Always returns ``coverage`` and ``source_fact_ids``: a summary that hides how
+    much it covered is the opaque generic summary issue #113 warned against.
+    Reads memory.db directly; never runs during remember or recall.
+    """
+    from datetime import date as _date, timedelta as _timedelta
+
+    kind = (kind or "day").strip().lower()
+    if kind not in ("day", "project", "session"):
+        raise HTTPException(status_code=400, detail=f"unknown summary kind '{kind}'")
+
+    profile = get_active_profile()
+    from superlocalmemory.infra.data_root import state_path
+    db_path = state_path("memory.db")
+    if not db_path.exists():
+        raise HTTPException(status_code=404, detail="no memory database")
+
+    # Pass the loaded config so Mode B/C write the summary. Omitting it silently
+    # forces the extractive path for every caller regardless of mode.
+    try:
+        from superlocalmemory.core.config import SLMConfig
+        cfg = SLMConfig.load()
+    except Exception:
+        cfg = None
+
+    try:
+        if kind == "day":
+            from superlocalmemory.summaries import generate_daily_reflection
+            day = (target or "").strip() or _date.today().isoformat()
+            if day == "today":
+                day = _date.today().isoformat()
+            elif day == "yesterday":
+                day = (_date.today() - _timedelta(days=1)).isoformat()
+            result = generate_daily_reflection(db_path, day, profile, cfg)
+        elif kind == "project":
+            if not (target or "").strip():
+                raise HTTPException(status_code=400, detail="project requires target")
+            from superlocalmemory.summaries import generate_project_work_log
+            result = generate_project_work_log(db_path, target.strip(), profile, cfg)
+        else:
+            if not (target or "").strip():
+                raise HTTPException(status_code=400, detail="session requires target")
+            from superlocalmemory.summaries import generate_session_summary
+            result = generate_session_summary(db_path, target.strip(), profile, cfg)
+    except HTTPException:
+        raise
+    except Exception:
+        raise _internal_error("Summary generation error")
+
+    return {
+        "kind": result.kind,
+        "profile_id": result.profile_id,
+        "summary": result.content,
+        "coverage": result.coverage,
+        "generated_by": result.generated_by,
+        "source_fact_ids": result.source_fact_ids,
+        "source_count": len(result.source_fact_ids),
+        "metadata": result.metadata,
+    }
+
+
+@router.get("/api/summary/projects")
+async def get_summary_projects(request: Request):
+    """Projects SuperLocalMemory has actually observed, for the summary picker.
+
+    WHY THIS EXISTS
+    ---------------
+    SLM is installed globally and the dashboard is a browser tab — it has no
+    working directory, so there is no such thing as "this project" from the
+    server's point of view. 4.0.8 shipped a "This project" button that sent an
+    empty target and produced "project requires target" every time. A button
+    that cannot know its own answer is the wrong control; a list of the projects
+    we have seen is the right one.
+
+    Scope comes from ``tool_events.project_path`` — the directory an agent was
+    working in when it called SLM. Deliberately NOT ``entity_profiles.
+    project_name``, which has exactly one distinct value on a real store (see
+    the note at the top of summaries/project_work_log.py).
+
+    ``tool_events`` is a bounded ring buffer, so this lists recently active
+    projects rather than every project in history. ``truncated`` says so
+    honestly instead of implying the list is exhaustive.
+    """
+    profile = get_active_profile()
+    try:
+        conn = get_db_connection()
+        # get_db_connection() hands back a SHARED read connection, and other
+        # handlers set row_factory on it. Never index these rows positionally —
+        # whichever handler ran last decides whether r[0] is a column or a
+        # KeyError. Name the columns and read them by name.
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT project_path AS path, COUNT(*) AS events
+              FROM tool_events
+             WHERE project_path IS NOT NULL AND project_path != ''
+               AND profile_id = ?
+             GROUP BY project_path
+             ORDER BY events DESC
+             LIMIT 50
+            """,
+            (profile,),
+        )
+        rows = cursor.fetchall()
+        total = cursor.execute(
+            "SELECT COUNT(*) AS n FROM tool_events"
+        ).fetchone()["n"]
+    except Exception:
+        raise _internal_error("Project list error")
+
+    projects = [
+        {
+            "path": r["path"],
+            "events": r["events"],
+            "label": _project_label(r["path"]),
+        }
+        for r in rows
+    ]
+    return {
+        "projects": projects,
+        "profile_id": profile,
+        # Surfaced so the UI can explain an unexpectedly short list rather than
+        # leaving the user to assume their project was never recorded.
+        "truncated": total >= _TOOL_EVENT_RING_SIZE,
+        "event_rows": total,
+    }
+
+
+#: tool_events is capped; at the cap the project list is a recent window, not history.
+_TOOL_EVENT_RING_SIZE = 2000
+
+
+def _project_label(path: str) -> str:
+    """Short, human label for a project path.
+
+    Full paths are long and share prefixes ("/Users/x/Documents/official/..."),
+    so a dropdown of raw paths is unreadable. Last two segments keep sibling
+    projects distinguishable without the noise.
+    """
+    parts = [p for p in str(path).replace("\\", "/").split("/") if p]
+    if not parts:
+        return str(path)
+    return "/".join(parts[-2:]) if len(parts) > 1 else parts[-1]
+
+
 @router.get("/api/clusters")
 async def get_clusters(request: Request):
     """Get cluster information with member counts and statistics."""

package/src/superlocalmemory/server/routes/v3_api.py

@@ -1932,55 +1932,33 @@ async def trigger_consolidation(request: Request):
             profile_id=pid,
         )
 
-        # v3.7.8 SEC-M-01: the prior "WorkerPool" fast path called
-        # ``pool.send_command(...)``, a method that does not exist on
-        # WorkerPool — every call raised AttributeError, was silently
-        # swallowed by the bare ``except``, and fell through to this direct
-        # path unconditionally. That dead branch is removed; consolidation
-        # always runs directly against a lease-protected DB connection so a
-        # concurrent profile switch cannot commit mid-consolidation.
-        #
-        # v3.4.64: ConsolidationEngine.consolidate() is CPU/IO bound (seconds
-        # to minutes). Calling it directly in an async route blocks the ASGI
-        # event loop.  Moved into asyncio.to_thread() so the event loop stays
-        # live.  The runtime.operation() lease is acquired INSIDE the thread —
-        # blocking a thread is fine; blocking the event loop is not.
-        import asyncio as _asyncio
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.storage.database import DatabaseManager
-        from superlocalmemory.storage import schema as _schema
-        from superlocalmemory.core.consolidation_engine import ConsolidationEngine
-        from superlocalmemory.server.profile_runtime import get_profile_runtime
-
-        _app_state = request.app.state
+        # 4.0.8: the body of this handler moved to server/consolidation_runner
+        # so the periodic daemon trigger and this endpoint run the SAME code
+        # under the SAME lock. Two copies would be two definitions of
+        # "consolidated", and only one of them would get maintained.
+        from superlocalmemory.server.consolidation_runner import (
+            run_full_consolidation,
+        )
 
-        def _run_consolidation() -> dict:
-            runtime = get_profile_runtime(_app_state)
-            with runtime.operation():
-                config = SLMConfig.load()
-                db = DatabaseManager(config.db_path)
-                db.initialize(_schema)
-                engine = ConsolidationEngine(
-                    db=db, config=config.consolidation, slm_config=config,
+        # background=true returns as soon as the pass is scheduled. The
+        # session-end hook needs this: a full consolidation runs for seconds to
+        # minutes, and a hook that waits for it either blocks the user's shell
+        # or times out and wrongly concludes the run failed.
+        if body.get("background"):
+            import asyncio as _asyncio
+
+            _app_state = request.app.state
+            _asyncio.create_task(
+                run_full_consolidation(
+                    _app_state, pid, lightweight=lightweight, trigger="hook",
                 )
-                res = engine.consolidate(profile_id=pid, lightweight=lightweight)
-                # v3.4.1: Auto-trigger behavioral pattern mining after consolidation
-                try:
-                    from superlocalmemory.learning.consolidation_worker import (
-                        ConsolidationWorker,
-                    )
-                    learning_db = config.base_dir / "learning.db"
-                    cw = ConsolidationWorker(str(config.db_path), str(learning_db))
-                    pattern_count = cw._generate_patterns(pid, False)
-                    res["patterns_mined"] = pattern_count
-                    logger.info(
-                        "Auto-mined %d patterns after consolidation", pattern_count
-                    )
-                except Exception as exc:
-                    logger.debug("Pattern mining after consolidation failed: %s", exc)
-            return res
+            )
+            authorization.complete()
+            return {"success": True, "started": True, "background": True}
 
-        result = await _asyncio.to_thread(_run_consolidation)
+        result = await run_full_consolidation(
+            request.app.state, pid, lightweight=lightweight, trigger="http",
+        )
         authorization.complete()
         return {"success": True, **result}
     except HTTPException:

package/src/superlocalmemory/server/unified_daemon.py

@@ -418,6 +418,10 @@ class EngineRecallAdapter:
             memory_map={k: _sanitize_json_text(v) for k, v in memory_map.items()},
             per_fact_max=getattr(_rc, "recall_per_fact_max_chars", 2400),
             total_max=getattr(_rc, "recall_total_max_chars", 12000),
+            # Option B: markers only on session-bearing recalls. A marker can
+            # only buy a learning signal when a pending_outcomes row exists
+            # to settle, and those exist only when session_id is present.
+            include_marker=bool(session_id),
         )
         for _r in results:
             _r["content"] = _sanitize_json_text(_r.get("content", ""))
@@ -860,6 +864,86 @@ def _start_idle_watchdog(timeout_sec: int) -> None:
     t.start()
 
 
+# ---------------------------------------------------------------------------
+# Periodic full consolidation (4.0.8)
+# ---------------------------------------------------------------------------
+#
+# Steps 8-11 of ConsolidationEngine — behavioural assertions, soft prompts,
+# skill performance, skill evolution — had no automatic trigger at all. The
+# session-end hook is the fast path; this timer is the guarantee, because a hook
+# that does not fire is indistinguishable from a feature that does not exist.
+#
+# Two constraints shape the schedule:
+#
+#   1. Remember and recall latency must not move. So the pass only starts when
+#      the daemon has served nothing for _CONSOLIDATION_IDLE_SEC. Consolidation
+#      is catch-up work; there is never a reason for it to compete with a live
+#      request. If the machine is busy every time we look, we simply skip and
+#      check again next tick.
+#   2. It must not pile up. run_full_consolidation() holds a lock and skips
+#      rather than queues, so a slow pass cannot be overlapped by the next tick
+#      or by the session-end hook.
+
+#: How often to consider running. Not how often it runs.
+_CONSOLIDATION_CHECK_SEC = int(os.environ.get("SLM_CONSOLIDATION_CHECK_SEC", 900))
+
+#: Minimum quiet period before a scheduled pass may start.
+_CONSOLIDATION_IDLE_SEC = int(os.environ.get("SLM_CONSOLIDATION_IDLE_SEC", 300))
+
+#: Minimum gap between two scheduled passes.
+_CONSOLIDATION_MIN_GAP_SEC = int(
+    os.environ.get("SLM_CONSOLIDATION_MIN_GAP_SEC", 6 * 3600)
+)
+
+#: Delay before the first check, so daemon startup is never slowed by it.
+_CONSOLIDATION_FIRST_DELAY_SEC = int(
+    os.environ.get("SLM_CONSOLIDATION_FIRST_DELAY_SEC", 120)
+)
+
+
+async def _consolidation_timer_loop(application: FastAPI) -> None:
+    """Run full consolidation on a schedule, but only while the daemon is idle."""
+    from superlocalmemory.server.consolidation_runner import run_full_consolidation
+
+    await asyncio.sleep(_CONSOLIDATION_FIRST_DELAY_SEC)
+    last_run = 0.0
+
+    while True:
+        try:
+            await asyncio.sleep(_CONSOLIDATION_CHECK_SEC)
+
+            now = time.monotonic()
+            if last_run and (now - last_run) < _CONSOLIDATION_MIN_GAP_SEC:
+                continue
+            if (now - _last_activity) < _CONSOLIDATION_IDLE_SEC:
+                continue  # busy — try again next tick
+
+            # get_engine_lazy, not state.engine directly: a mode switch nulls
+            # state.engine, and reading it raw would silently disable scheduled
+            # consolidation until the next daemon restart.
+            from superlocalmemory.server.routes.helpers import get_engine_lazy
+
+            engine = get_engine_lazy(application.state)
+            profile_id = getattr(engine, "profile_id", None) if engine else None
+            if not profile_id:
+                continue
+
+            result = await run_full_consolidation(
+                application.state, profile_id, trigger="timer",
+            )
+            # Only a pass that actually ran resets the clock; a skip must not
+            # buy another six hours of silence.
+            if not result.get("skipped"):
+                last_run = time.monotonic()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            # Never let a bad pass kill the loop — that would silently disable
+            # consolidation for the life of the daemon, which is the failure
+            # mode this timer exists to end. Log loudly and try again.
+            logger.exception("scheduled consolidation failed; will retry")
+
+
 # ---------------------------------------------------------------------------
 # Legacy port TCP redirect (backward compat for port 8767)
 # ---------------------------------------------------------------------------
@@ -2462,6 +2546,15 @@ async def lifespan(application: FastAPI):
     except Exception as e:
         logger.warning("optimize module not available: %s", e)
 
+    # 4.0.8: periodic full consolidation. Idle-gated and lock-guarded — see
+    # _consolidation_timer_loop. Started here rather than at import so a daemon
+    # that never completes startup never schedules work.
+    _consol_task = getattr(application.state, "_consolidation_task", None)
+    if _consol_task is None or _consol_task.done():
+        application.state._consolidation_task = asyncio.create_task(
+            _consolidation_timer_loop(application)
+        )
+
     # v3.6.7: Start MCP Streamable-HTTP session manager (GOTCHA #1).
     # streamable_http_app() carries its own Starlette lifespan that initialises
     # an anyio task group inside the session manager. Without entering that
@@ -2537,6 +2630,16 @@ async def lifespan(application: FastAPI):
     except Exception:  # pragma: no cover — defensive
         pass
 
+    # Cancel the periodic consolidation loop. Not awaited to completion — a pass
+    # can take minutes and shutdown must not block on it; the lock and the
+    # engine's own transaction boundaries make an interrupted pass safe to redo.
+    try:
+        _consol = getattr(application.state, "_consolidation_task", None)
+        if _consol is not None and not _consol.done():
+            _consol.cancel()
+    except Exception:  # pragma: no cover — defensive
+        pass
+
     # Cancel optimize metrics flush loop + run final flush before shutdown
     try:
         _flush_task = getattr(application.state, "_optimize_flush_task", None)
@@ -3879,6 +3982,10 @@ def _register_daemon_routes(application: FastAPI) -> None:
                 memory_map={k: _sanitize_json_text(v) for k, v in memory_map.items()},
                 per_fact_max=getattr(_rc, "recall_per_fact_max_chars", 2400),
                 total_max=getattr(_rc, "recall_total_max_chars", 12000),
+                # Option B: markers only on session-bearing recalls. A marker can
+                # only buy a learning signal when a pending_outcomes row exists
+                # to settle, and those exist only when session_id is present.
+                include_marker=bool(session_id),
                 full=full,
                 include_source=include_source,
             )

package/src/superlocalmemory/summaries/base.py

@@ -98,6 +98,165 @@ GENERATED_BY_LLM_C = "llm_c"
 """Cloud LLM (Mode C).  Falls back via llm_b to extractive."""
 
 
+# ── highlight formatting ────────────────────────────────────────────────────
+
+#: Display width for one bullet in a summary body.
+#:
+#: Chosen for a bullet, not for a paragraph. The generators originally truncated
+#: at 300 characters and nothing else, which looks fine on a synthetic corpus of
+#: one-line facts and falls apart on a real store: agent-written facts routinely
+#: contain blank lines and markdown headings, so a 300-character slice rendered
+#: as six or more display lines and the bullet list stopped being a list.
+HIGHLIGHT_CHARS = 180
+
+
+def format_highlight(content: str, limit: int = HIGHLIGHT_CHARS) -> str:
+    """Collapse *content* to a single readable line for a summary bullet.
+
+    Three things, in order:
+
+    1. **Flatten whitespace.** Newlines, blank lines and runs of spaces all
+       become one space. This is the fix that matters: character truncation
+       alone cannot keep a multi-paragraph fact on one line, and every
+       generator here writes into a bullet list.
+    2. **Prefer a whole first sentence** when there is one and it fits. A
+       complete sentence reads better than a slice of one, and the first
+       sentence of a report is usually its summary.
+    3. **Otherwise cut at a word boundary** and mark the cut with an ellipsis,
+       so it is visible that text was dropped rather than that a fact ended
+       mid-word.
+
+    Markdown heading markers are stripped because a flattened ``**Summary**``
+    mid-sentence reads as noise.
+    """
+    import re
+
+    text = re.sub(r"\s+", " ", (content or "")).strip()
+    # Leading/inline markdown emphasis and heading marks, once flattened, add
+    # nothing but clutter to a one-line bullet.
+    text = re.sub(r"(?:^|\s)#{1,6}\s+", " ", text)
+    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)
+    text = re.sub(r"\s+", " ", text).strip()
+
+    if not text:
+        return ""
+    if len(text) <= limit:
+        return text
+
+    # A complete first sentence, if it fits comfortably.
+    match = re.match(r"(.+?[.!?])(?:\s|$)", text)
+    if match:
+        sentence = match.group(1).strip()
+        if len(sentence) <= limit:
+            return sentence
+
+    cut = text[:limit]
+    space = cut.rfind(" ")
+    if space > limit * 0.6:          # don't cut a long unbroken token to a stub
+        cut = cut[:space]
+    return cut.rstrip(" ,;:—-") + "…"
+
+
+# ── LLM output cleanup ──────────────────────────────────────────────────────
+
+#: Sentences a chat-tuned model emits *around* the answer rather than as part of
+#: it. Anchored to the start of a paragraph so they cannot match mid-content.
+#:
+#: Measured, not guessed: a Mode B summary on the author's own store opened with
+#: "I apologize for the previous confusion. It seems that I misunderstood the
+#: context of the texts provided.\n\nTo provide a concise summary paragraph, here
+#: is a merge of all the key information:" — 180 characters of the model talking
+#: to itself, shown to the user as their daily reflection.
+_LLM_PREAMBLE = (
+    r"^(?:"
+    r"i\s+apologi[sz]e\b.*"
+    r"|i'?m\s+sorry\b.*"
+    r"|it\s+seems\s+that\s+i\b.*"
+    r"|sure[,!.]?\s*(?:thing)?\b.*"
+    r"|certainly[,!.]?\b.*"
+    r"|of\s+course[,!.]?\b.*"
+    r"|here(?:'s|\s+is|\s+are)\b[^.!?]*:"
+    r"|to\s+(?:provide|summari[sz]e|answer)\b[^.!?]*:"
+    r"|based\s+on\s+the\s+(?:facts|texts|information|data)\s+provided[,:]?"
+    r"|as\s+(?:an|a)\s+(?:ai|language\s+model)\b.*"
+    r")\s*$"
+)
+
+#: Closing pleasantries. Same anchoring rule.
+_LLM_POSTAMBLE = (
+    r"^(?:"
+    r"(?:i\s+hope|hope)\s+(?:this|that)\s+helps\b.*"
+    r"|let\s+me\s+know\b.*"
+    r"|feel\s+free\s+to\b.*"
+    r"|would\s+you\s+like\s+me\s+to\b.*"
+    r")$"
+)
+
+
+def clean_llm_summary(text: str) -> str:
+    """Strip chat-assistant scaffolding from a model-written summary.
+
+    WHY THIS EXISTS
+    ---------------
+    Mode B/C summaries are shown to the user as *their* memory, with no chat
+    framing around them. A chat-tuned model does not know that: it opens with an
+    apology or "Here is a concise summary:" and closes with "Let me know if you
+    want more detail". Both are addressed to a conversation that the reader
+    cannot see, and both make the product look broken.
+
+    The system prompt now asks for bare prose, which handles most of it. This is
+    the second line of defence, because instruction-following on a 3B local
+    model is not something to bet the displayed output on.
+
+    Conservative by construction: patterns are anchored to whole paragraphs or
+    whole leading sentences, so a summary that legitimately contains the word
+    "sure" mid-paragraph is untouched. If stripping would empty the text, the
+    original is returned — a scaffolded summary beats a blank one.
+    """
+    import re
+
+    original = (text or "").strip()
+    if not original:
+        return ""
+
+    # Fenced code blocks wrapping the whole answer: keep the contents.
+    fenced = re.match(r"^```[a-zA-Z]*\n(.*?)\n?```$", original, re.DOTALL)
+    if fenced:
+        original = fenced.group(1).strip()
+
+    paras = [p.strip() for p in re.split(r"\n\s*\n", original) if p.strip()]
+
+    while paras and re.match(_LLM_PREAMBLE, paras[0], re.IGNORECASE | re.DOTALL):
+        paras.pop(0)
+    while paras and re.match(_LLM_POSTAMBLE, paras[-1], re.IGNORECASE | re.DOTALL):
+        paras.pop()
+
+    if not paras:
+        return original
+
+    # A preamble that shares a paragraph with real content: drop just the leading
+    # sentence, and only when what follows is substantial enough to stand alone.
+    lead = re.match(r"(.+?[.:!?])\s+(\S.*)$", paras[0], re.DOTALL)
+    if lead and re.match(_LLM_PREAMBLE, lead.group(1), re.IGNORECASE | re.DOTALL):
+        if len(lead.group(2).strip()) > 40:
+            paras[0] = lead.group(2).strip()
+
+    cleaned = "\n\n".join(paras).strip()
+    return cleaned or original
+
+
+#: System prompt for every summary generator, Mode B and Mode C alike.
+#:
+#: Mode C always sent one; Mode B sent none at all, which is why local-model
+#: output arrived wrapped in chat scaffolding while cloud output did not.
+SUMMARY_SYSTEM_PROMPT = (
+    "You summarise a person's own saved notes for them. "
+    "Reply with the summary text only — no preamble, no apologies, no sign-off, "
+    "no markdown headings, and never refer to yourself or to these instructions. "
+    "Write plain prose in the third person about the work described."
+)
+
+
 def get_mode_str(config: object | None) -> str:
     """Extract the operating mode string ('a', 'b', or 'c') from a config."""
     if config is None:

package/src/superlocalmemory/summaries/daily_reflection.py

@@ -34,6 +34,9 @@ from datetime import date
 from pathlib import Path
 
 from .base import (
+    clean_llm_summary,
+    format_highlight,
+    SUMMARY_SYSTEM_PROMPT,
     COVERAGE_FULL,
     COVERAGE_INSUFFICIENT,
     COVERAGE_UNAVAILABLE,
@@ -128,7 +131,7 @@ def generate_daily_reflection(
         coverage = COVERAGE_FULL
 
     # ── extractive summary (deterministic, always available) ──────────────────
-    extractive_content = _build_extractive_content(date_str, facts, fact_count)
+    extractive_content = _build_extractive_content(date_str, facts, fact_count, db_path, profile_id)
 
     # ── LLM enrichment (optional) ─────────────────────────────────────────────
     mode = get_mode_str(config)
@@ -162,8 +165,14 @@ def _build_extractive_content(
     date_str: str,
     facts: list[dict],
     fact_count: int,
+    db_path: str | Path,
+    profile_id: str,
 ) -> str:
-    """Build a deterministic extractive daily reflection."""
+    """Build a deterministic extractive daily reflection.
+
+    ``db_path`` / ``profile_id`` are needed only to turn entity IDs into names
+    for the "Active entities" line — the facts themselves are already loaded.
+    """
     import json
 
     lines = [
@@ -174,8 +183,7 @@ def _build_extractive_content(
     ]
     for f in facts[:_BODY_FACTS]:
         content = f.get("content", "")
-        if len(content) > _MAX_FACT_CHARS:
-            content = content[:_MAX_FACT_CHARS - 3] + "..."
+        content = format_highlight(content)
         lines.append(f"  - {content}")
     if fact_count > _BODY_FACTS:
         lines.append(f"  ... and {fact_count - _BODY_FACTS} additional facts.")
@@ -193,13 +201,50 @@ def _build_extractive_content(
 
     if entity_counts:
         top_entities = sorted(entity_counts.items(), key=lambda x: x[1], reverse=True)[:5]
-        entity_str = ", ".join(f"{e} ({c})" for e, c in top_entities)
+        # Resolve to names. canonical_entities_json stores entity IDs, so this
+        # line previously read "Active entities: 1666abc512904473 (127),
+        # 84288f2dde994afe (124)" — five 16-hex identifiers, which tell a reader
+        # nothing. They resolve to 'Fixed', 'Gateway', 'REVISED' and so on. This
+        # is the same defect 4.0.6 fixed in the Living Brain, where source
+        # quality listed internal identifiers; it survived here because this
+        # generator was never reachable to be looked at.
+        names = _entity_names(db_path, [e for e, _ in top_entities], profile_id)
+        labelled = [
+            (names.get(eid) or eid, count) for eid, count in top_entities
+        ]
+        entity_str = ", ".join(f"{name} ({c})" for name, c in labelled)
         lines.append("")
         lines.append(f"Active entities: {entity_str}")
 
     return "\n".join(lines)
 
 
+def _entity_names(
+    db_path: str | Path, entity_ids: list[str], profile_id: str
+) -> dict[str, str]:
+    """Map entity_id → canonical_name. Missing or unreadable rows are omitted.
+
+    Fail-open: a summary is still useful with a raw id in it, so a query problem
+    must not lose the whole line. The caller falls back to the id per entity.
+    """
+    if not entity_ids:
+        return {}
+    try:
+        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        try:
+            placeholders = ",".join("?" for _ in entity_ids)
+            rows = conn.execute(
+                f"SELECT entity_id, canonical_name FROM canonical_entities "
+                f"WHERE entity_id IN ({placeholders}) AND profile_id = ?",
+                (*entity_ids, profile_id),
+            ).fetchall()
+        finally:
+            conn.close()
+        return {r[0]: r[1] for r in rows if r[1]}
+    except sqlite3.Error:
+        return {}
+
+
 def _try_llm(
     date_str: str,
     facts: list[dict],
@@ -249,6 +294,7 @@ def _call_ollama(
         payload = json.dumps({
             "model": model,
             "prompt": full_prompt,
+            "system": SUMMARY_SYSTEM_PROMPT,
             "stream": False,
             "options": {"num_predict": 300},
         }).encode()
@@ -259,7 +305,7 @@ def _call_ollama(
         )
         resp = urllib.request.urlopen(req, timeout=timeout)
         data = json.loads(resp.read().decode())
-        text = data.get("response", "").strip()
+        text = clean_llm_summary(data.get("response", ""))
         return text if text and len(text) > 20 else None
     except Exception as exc:
         logger.debug("Ollama daily reflection failed: %s", exc)
@@ -283,11 +329,12 @@ def _call_cloud_llm(
         full_prompt = f"{prompt}\n\nFacts:\n{fact_texts}"
         text = llm.generate(
             prompt=full_prompt,
-            system="You are a concise personal memory summariser.",
+            system=SUMMARY_SYSTEM_PROMPT,
             max_tokens=300,
             temperature=0.1,
         )
-        return text.strip() if text and len(text.strip()) > 20 else None
+        cleaned = clean_llm_summary(text or "")
+        return cleaned if len(cleaned) > 20 else None
     except Exception as exc:
         logger.debug("Cloud LLM daily reflection failed: %s", exc)
         return None