superlocalmemory 4.0.6 → 4.0.8

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/storage/schema_code_graph.py

@@ -104,11 +104,49 @@ _DDL_STATEMENTS: tuple[str, ...] = (
         confidence      REAL NOT NULL DEFAULT 0.8 CHECK (confidence >= 0.0 AND confidence <= 1.0),
         created_at      TEXT NOT NULL DEFAULT (datetime('now')),
         last_verified   TEXT,
-        is_stale        INTEGER NOT NULL DEFAULT 0
+        is_stale        INTEGER NOT NULL DEFAULT 0,
+        enriched_description TEXT
     )
     """,
 )
 
+#: Columns added to existing tables after their first release.
+#:
+#: This file's DDL is all ``CREATE TABLE IF NOT EXISTS`` and code_graph.db has
+#: no migration framework, so appending a column to a _DDL_STATEMENTS block
+#: reaches NEW databases only — every database created by an earlier version
+#: skips the statement entirely and never gains the column. That silent
+#: divergence is what this list exists to close.
+#:
+#: ADDITIVE ONLY: ``ALTER TABLE ... ADD COLUMN`` with no NOT NULL and no
+#: default, so it cannot fail on a populated table and cannot rewrite a row.
+#: Never put a DROP, a RENAME, or a type change here.
+_ADDITIVE_COLUMNS: tuple[tuple[str, str, str], ...] = (
+    # (table, column, type) — enrichment text for a code↔memory link. Lives
+    # here rather than in memory.db so the user's own fact wording is never
+    # overwritten, and so recall (which never opens code_graph.db) is unaffected.
+    ("code_memory_links", "enriched_description", "TEXT"),
+)
+
+
+def _apply_additive_columns(cursor: sqlite3.Cursor) -> None:
+    """Add any missing column from _ADDITIVE_COLUMNS. Idempotent."""
+    for table, column, coltype in _ADDITIVE_COLUMNS:
+        try:
+            existing = {row[1] for row in cursor.execute(f"PRAGMA table_info({table})")}
+        except sqlite3.Error as exc:  # table absent on a partial database
+            logger.debug("additive column probe skipped for %s: %s", table, exc)
+            continue
+        if not existing or column in existing:
+            continue
+        try:
+            cursor.execute(f"ALTER TABLE {table} ADD COLUMN {column} {coltype}")
+            logger.info("code_graph schema: added %s.%s", table, column)
+        except sqlite3.OperationalError as exc:
+            # Concurrent initialiser won the race, or the column appeared
+            # between the probe and the ALTER. Both are benign.
+            logger.debug("additive column %s.%s not applied: %s", table, column, exc)
+
 # Indexes (separate from tables for clarity)
 _INDEX_STATEMENTS: tuple[str, ...] = (
     # graph_nodes indexes
@@ -194,6 +232,11 @@ def create_all_tables(conn: sqlite3.Connection) -> None:
     for ddl in _DDL_STATEMENTS:
         cursor.execute(ddl)
 
+    # Columns added after a table's first release. Must run AFTER the CREATEs
+    # (so a fresh database already has them and this is a no-op) and BEFORE the
+    # indexes (in case one is ever declared on an added column).
+    _apply_additive_columns(cursor)
+
     # Indexes
     for idx in _INDEX_STATEMENTS:
         cursor.execute(idx)

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

package/src/superlocalmemory/summaries/project_work_log.py

@@ -39,8 +39,12 @@ from collections import Counter
 from pathlib import Path
 
 from .base import (
+    clean_llm_summary,
+    format_highlight,
+    SUMMARY_SYSTEM_PROMPT,
     COVERAGE_FULL,
     COVERAGE_INSUFFICIENT,
+    COVERAGE_PARTIAL,
     COVERAGE_UNAVAILABLE,
     GENERATED_BY_EXTRACTIVE,
     GENERATED_BY_LLM_B,
@@ -121,8 +125,19 @@ def generate_project_work_log(
     event_count = len(tool_rows)
     fact_count = len(facts_rows)
 
-    coverage = COVERAGE_FULL if (event_count >= _MIN_EVENTS or fact_count >= _MIN_FACTS) \
-        else COVERAGE_INSUFFICIENT
+    # A project work log has two inputs: what was DONE (tool events) and what was
+    # LEARNED (facts). "full" means both were there.
+    #
+    # The previous rule was `events >= 1 OR facts >= 1`, which reported "full" for
+    # a project with 86 tool events and zero facts — rendered in the dashboard as
+    # "Built from 0 memories · coverage: full". Claiming full coverage of nothing
+    # is precisely the dishonest summary issue #113 exists to prevent.
+    if event_count >= _MIN_EVENTS and fact_count >= _MIN_FACTS:
+        coverage = COVERAGE_FULL
+    elif event_count >= _MIN_EVENTS or fact_count >= _MIN_FACTS:
+        coverage = COVERAGE_PARTIAL
+    else:
+        coverage = COVERAGE_INSUFFICIENT
 
     extractive_content = _build_extractive_content(
         project_path, tool_rows, facts_rows, event_count, fact_count
@@ -302,8 +317,7 @@ def _build_extractive_content(
         lines.append("Key facts from project sessions:")
         for f in facts_rows[:_TOP_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 > _TOP_FACTS:
             lines.append(f"  ... and {fact_count - _TOP_FACTS} more facts.")
@@ -373,6 +387,7 @@ def _call_ollama(
         payload = json.dumps({
             "model": model,
             "prompt": full_prompt,
+            "system": SUMMARY_SYSTEM_PROMPT,
             "stream": False,
             "options": {"num_predict": 300},
         }).encode()
@@ -383,7 +398,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 project work log failed: %s", exc)
@@ -414,11 +429,12 @@ def _call_cloud_llm(
         )
         text = llm.generate(
             prompt=full_prompt,
-            system="You are a concise project activity 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 project work log failed: %s", exc)
         return None

package/src/superlocalmemory/summaries/session_summary.py

@@ -37,6 +37,9 @@ from datetime import date, timezone
 from pathlib import Path
 
 from .base import (
+    clean_llm_summary,
+    format_highlight,
+    SUMMARY_SYSTEM_PROMPT,
     COVERAGE_FULL,
     COVERAGE_INSUFFICIENT,
     COVERAGE_NO_SESSION,
@@ -209,8 +212,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} more facts.")
@@ -263,6 +265,7 @@ def _call_ollama(
         payload = json.dumps({
             "model": model,
             "prompt": full_prompt,
+            "system": SUMMARY_SYSTEM_PROMPT,
             "stream": False,
             "options": {"num_predict": 200},
         }).encode()
@@ -273,7 +276,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 session summary failed: %s", exc)
@@ -297,11 +300,12 @@ def _call_cloud_llm(
         full_prompt = f"{prompt}\n\nFacts:\n{fact_texts}\n\nRespond in 2-4 sentences."
         text = llm.generate(
             prompt=full_prompt,
-            system="You are a concise memory summariser.",
+            system=SUMMARY_SYSTEM_PROMPT,
             max_tokens=200,
             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 session summary failed: %s", exc)
         return None

package/src/superlocalmemory/ui/index.html

@@ -1017,6 +1017,11 @@
                 <div id="skill-detail-panel" style="display:none;margin-top:24px"></div>
             </div>
 
+            <!-- Bounded Loops (v4.0.8) — moved out of Governance: it is a
+                 separate product SLM optionally observes, i.e. an integration.
+                 Rendered entirely by od-boundedloops.js (window.odRenderLoops). -->
+            <div class="tab-pane fade" id="loops-pane"></div>
+
             <!-- Mesh Peers (v3.4.3 — Neural Glass) -->
             <div class="tab-pane fade" id="mesh-pane">
                 <div class="ng-content-header">
@@ -1575,7 +1580,7 @@
     <script src="static/js/math-health.js"></script>
     <script src="static/js/auto-settings.js"></script>
     <script src="static/js/ide-status.js"></script>
-    <script src="static/js/fact-detail.js"></script>
+    <script src="static/js/fact-detail.js?v=e9076ee3"></script>
 
     <!-- Neural Glass shell (v3.4.21 restructured) -->
     <script src="static/js/ng-health.js?v=345"></script>
@@ -1599,13 +1604,14 @@
     <script src="static/js/od-ops-health.js?v=400"></script>
     <script src="static/js/od-team.js?v=379"></script>
     <script src="static/js/od-graph.js?v=6812bf6c"></script>
-    <script src="static/js/od-memories.js?v=379"></script>
+    <script src="static/js/od-memories.js?v=022ff653"></script>
     <script src="static/js/od-entities.js?v=379"></script>
     <!-- Multi-Agent Memory pane (v3.8.0): visualises memory written by multiple agents -->
     <script src="static/js/od-agents.js?v=c75ff3c2"></script>
     <script src="static/js/od-skills.js?v=379"></script>
-    <script src="static/js/od-mesh.js?v=379"></script>
-    <script src="static/js/od-optimize.js?v=379"></script>
+    <script src="static/js/od-boundedloops.js?v=b4a014a1"></script>
+    <script src="static/js/od-mesh.js?v=a7bc694a"></script>
+    <script src="static/js/od-optimize.js?v=1f511698"></script>
     <script src="static/js/od-settings.js?v=386"></script>
     <script src="static/js/od-backup.js?v=379"></script>
     <!-- MCP & Integrations pane (v3.8.0): shows exposed MCP tool profile + counts -->