fix: rebrand viewer, fix embedding warning, fix memory_add/search order (#1446)

## Summary

### 1. Rebrand viewer from OpenClaw to MemTensor
- Replace all 28 user-visible "OpenClaw" references with "MemTensor" in
the memory viewer UI
- Update `server.ts` branding replacement regex to match new text

### 2. Fix embedding warning banner
- Banner now dismisses when a configured (non-local) embedding provider
is detected
- Previously the warning persisted forever after first page load due to
`_embeddingWarningShown` flag

### 3. Fix memory_add/search order (critical)
- **Problem**: Hermes calls `sync_all()` before `queue_prefetch_all()`,
so the current turn's data was ingested before the next prefetch search
ran. This caused every search to return the just-added turn content —
redundant and wasting context window.
- **Fix**: `sync_turn()` now defers ingest by stashing the data.
`queue_prefetch()` picks it up and flushes AFTER the search completes.
This ensures recalled memories never include the current turn.
- `on_session_end()` flushes any remaining deferred ingest to prevent
data loss.

## Changed files

| File | Change |
|------|--------|
| `adapters/hermes/__init__.py` | Defer ingest, search-before-add
ordering |
| `src/viewer/html.ts` | Rebrand OpenClaw → MemTensor, fix embedding
banner |
| `src/viewer/server.ts` | Update branding regex |

## Test plan

- [ ] Start `hermes chat`, send a message — verify logs show `search`
before `add`
- [ ] Verify search results don't contain the message just sent
- [ ] Verify viewer title shows "MemTensor Memory"
- [ ] Configure embedding model → warning banner disappears
- [ ] Exit session → verify deferred ingest is flushed (no data loss)

Author: hijzy

apps/memos-local-plugin/adapters/hermes/__init__.py

@@ -11,6 +11,7 @@
 import json
 import logging
 import os
+import re
 import sys
 import threading
 from pathlib import Path
@@ -46,6 +47,40 @@
 }
 
 
+_TRIVIAL_PATTERNS = [
+    re.compile(r'^\s*\{["\']?ok["\']?\s*:\s*true\s*\}\s*$', re.IGNORECASE),
+    re.compile(r'^\s*\{["\']?success["\']?\s*:\s*true\s*\}\s*$', re.IGNORECASE),
+    re.compile(r'^\s*\{["\']?status["\']?\s*:\s*["\']?ok["\']?\s*\}\s*$', re.IGNORECASE),
+    re.compile(r'^Operation interrupted:', re.IGNORECASE),
+    re.compile(r'^Error:', re.IGNORECASE),
+    re.compile(r'waiting for model response.*elapsed', re.IGNORECASE),
+    re.compile(r'^\s*$'),
+]
+
+_MIN_CONTENT_LENGTH = 6
+
+
+def _is_trivial(text: str) -> bool:
+    """Return True if *text* carries no meaningful information for long-term memory."""
+    if not text or len(text.strip()) < _MIN_CONTENT_LENGTH:
+        return True
+    stripped = text.strip()
+    for pat in _TRIVIAL_PATTERNS:
+        if pat.search(stripped):
+            return True
+    try:
+        obj = json.loads(stripped)
+        if isinstance(obj, dict) and len(obj) <= 2:
+            keys = {k.lower() for k in obj}
+            if keys <= {"ok", "success", "status", "result", "error", "message"}:
+                vals = list(obj.values())
+                if all(isinstance(v, (bool, type(None))) or (isinstance(v, str) and len(v) < 20) for v in vals):
+                    return True
+    except (json.JSONDecodeError, TypeError):
+        pass
+    return False
+
+
 class MemTensorProvider(MemoryProvider):
     """MemTensor semantic memory — recall across sessions via bridge daemon."""
 
@@ -56,6 +91,7 @@ def __init__(self) -> None:
         self._prefetch_lock = threading.Lock()
         self._prefetch_thread: threading.Thread | None = None
         self._sync_thread: threading.Thread | None = None
+        self._pending_ingest: tuple | None = None
 
     @property
     def name(self) -> str:
@@ -122,7 +158,11 @@ def prefetch(self, query: str, *, session_id: str = "") -> str:
         return f"## Recalled Memories\n{result}"
 
     def queue_prefetch(self, query: str, *, session_id: str = "") -> None:
+        pending = self._pending_ingest
+        self._pending_ingest = None
+
         def _run():
+            # 1) Search FIRST — before ingesting the current turn
             try:
                 text = self._do_recall(query)
                 if text:
@@ -131,6 +171,22 @@ def _run():
             except Exception as e:
                 logger.debug("MemTensor queue_prefetch failed: %s", e)
 
+            # 2) Now flush the deferred ingest so data is stored for future turns
+            if pending and self._bridge:
+                try:
+                    from config import OWNER
+                    user_content, assistant_content, sid = pending
+                    messages = []
+                    if user_content:
+                        messages.append({"role": "user", "content": user_content})
+                    if assistant_content:
+                        messages.append({"role": "assistant", "content": assistant_content})
+                    if messages:
+                        self._bridge.ingest(messages, session_id=sid, owner=OWNER)
+                        self._bridge.flush()
+                except Exception as e:
+                    logger.warning("MemTensor deferred sync_turn failed: %s", e)
+
         self._prefetch_thread = threading.Thread(
             target=_run, daemon=True, name="memtensor-prefetch"
         )
@@ -172,30 +228,26 @@ def _do_recall(self, query: str) -> str:
     def sync_turn(
         self, user_content: str, assistant_content: str, *, session_id: str = ""
     ) -> None:
+        """Queue turn data for deferred ingest.
+
+        Hermes calls sync_all() BEFORE queue_prefetch_all(), so ingesting
+        immediately would let the next prefetch retrieve the just-added turn.
+        Instead we stash the data and let queue_prefetch() flush it AFTER
+        the search completes — ensuring search results never contain the
+        current turn's content.
+        """
         if not self._bridge:
             return
-
+        if _is_trivial(user_content) and _is_trivial(assistant_content):
+            logger.debug("sync_turn: skipping trivial turn (user=%r, assistant=%r)",
+                         user_content[:80] if user_content else "", assistant_content[:80] if assistant_content else "")
+            return
+        if _is_trivial(user_content):
+            user_content = ""
+        if _is_trivial(assistant_content):
+            assistant_content = ""
         sid = session_id or self._session_id or "default"
-        messages = [
-            {"role": "user", "content": user_content},
-            {"role": "assistant", "content": assistant_content},
-        ]
-
-        def _sync():
-            try:
-                from config import OWNER
-                self._bridge.ingest(messages, session_id=sid, owner=OWNER)
-                self._bridge.flush()
-            except Exception as e:
-                logger.warning("MemTensor sync_turn failed: %s", e)
-
-        if self._sync_thread and self._sync_thread.is_alive():
-            self._sync_thread.join(timeout=5.0)
-
-        self._sync_thread = threading.Thread(
-            target=_sync, daemon=True, name="memtensor-sync"
-        )
-        self._sync_thread.start()
+        self._pending_ingest = (user_content, assistant_content, sid)
 
     def get_tool_schemas(self) -> List[Dict[str, Any]]:
         return [MEMORY_SEARCH_SCHEMA]
@@ -256,6 +308,22 @@ def _write():
     def on_session_end(self, messages: List[Dict[str, Any]]) -> None:
         if not self._bridge:
             return
+        # Flush any deferred ingest that hasn't been picked up by queue_prefetch
+        pending = self._pending_ingest
+        self._pending_ingest = None
+        if pending:
+            try:
+                from config import OWNER
+                user_content, assistant_content, sid = pending
+                msgs = []
+                if user_content:
+                    msgs.append({"role": "user", "content": user_content})
+                if assistant_content:
+                    msgs.append({"role": "assistant", "content": assistant_content})
+                if msgs:
+                    self._bridge.ingest(msgs, session_id=sid, owner=OWNER)
+            except Exception as e:
+                logger.debug("MemTensor deferred ingest on session end failed: %s", e)
         try:
             self._bridge.flush()
         except Exception as e:

apps/memos-local-plugin/adapters/hermes/config.py

@@ -54,8 +54,8 @@ def get_viewer_port() -> int:
     return VIEWER_PORT
 
 
-def _read_openclaw_model_config() -> dict:
-    """Read embedding/summarizer config from OpenClaw's openclaw.json as fallback."""
+def _read_host_model_config() -> dict:
+    """Read embedding/summarizer config from host agent's config as fallback."""
     home = os.environ.get("HOME", os.environ.get("USERPROFILE", ""))
     cfg_path = os.environ.get("OPENCLAW_CONFIG_PATH") or os.path.join(
         os.environ.get("OPENCLAW_STATE_DIR", os.path.join(home, ".openclaw")),
@@ -105,7 +105,7 @@ def get_bridge_config() -> dict:
             plugin_config["embedding"]["endpoint"] = endpoint
 
     if "embedding" not in plugin_config:
-        oc_config = _read_openclaw_model_config()
+        oc_config = _read_host_model_config()
         if oc_config.get("embedding"):
             plugin_config["embedding"] = oc_config["embedding"]
         if oc_config.get("summarizer"):

apps/memos-local-plugin/adapters/hermes/install.sh

@@ -11,7 +11,7 @@ set -euo pipefail
 #   - hermes-agent repository cloned locally
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-MEMOS_OPENCLAW_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+MEMOS_PLUGIN_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
 
 # hermes-agent location: first argument or auto-detect
 # Priority: CLI arg > hermes runtime dir > repo clone
@@ -32,7 +32,7 @@ TARGET_DIR="$HERMES_REPO/plugins/memory/memtensor"
 echo "=== MemTensor Memory Plugin Installer (hermes-agent) ==="
 echo ""
 echo "Plugin source:  $SCRIPT_DIR"
-echo "OpenClaw core:  $MEMOS_OPENCLAW_DIR"
+echo "Plugin root:    $MEMOS_PLUGIN_DIR"
 echo "Hermes repo:    $HERMES_REPO"
 echo "Install target: $TARGET_DIR"
 echo ""
@@ -57,11 +57,11 @@ fi
 
 echo "✓ Node.js $(node -v)"
 
-# ─── Install memos-local-openclaw dependencies ───
+# ─── Install plugin dependencies ───
 
 echo ""
-echo "Installing memos-local-openclaw dependencies..."
-cd "$MEMOS_OPENCLAW_DIR"
+echo "Installing plugin dependencies..."
+cd "$MEMOS_PLUGIN_DIR"
 
 if command -v pnpm &>/dev/null; then
   pnpm install --frozen-lockfile 2>/dev/null || pnpm install
@@ -76,7 +76,7 @@ echo "✓ Dependencies installed"
 
 # ─── Record bridge path for runtime discovery ───
 
-BRIDGE_CTS="$MEMOS_OPENCLAW_DIR/bridge.cts"
+BRIDGE_CTS="$MEMOS_PLUGIN_DIR/bridge.cts"
 echo "$BRIDGE_CTS" > "$SCRIPT_DIR/bridge_path.txt"
 
 if [ -f "$BRIDGE_CTS" ]; then

apps/memos-local-plugin/src/ingest/worker.ts

@@ -7,6 +7,40 @@ import { Summarizer } from "./providers";
 import { findDuplicate, findTopSimilar } from "./dedup";
 import { TaskProcessor } from "./task-processor";
 
+const TRIVIAL_CONTENT_RE = [
+  /^\s*\{["']?ok["']?\s*:\s*true\s*\}\s*$/i,
+  /^\s*\{["']?success["']?\s*:\s*true\s*\}\s*$/i,
+  /^\s*\{["']?status["']?\s*:\s*["']?ok["']?\s*\}\s*$/i,
+  /^Operation interrupted:/i,
+  /waiting for model response.*elapsed/i,
+  /^\s*$/,
+];
+const MIN_CONTENT_LENGTH = 6;
+
+function isTrivialContent(text: string): boolean {
+  if (!text || text.trim().length < MIN_CONTENT_LENGTH) return true;
+  const s = text.trim();
+  for (const re of TRIVIAL_CONTENT_RE) {
+    if (re.test(s)) return true;
+  }
+  try {
+    const obj = JSON.parse(s);
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      const keys = Object.keys(obj);
+      if (keys.length <= 2) {
+        const lowerKeys = new Set(keys.map(k => k.toLowerCase()));
+        const trivialKeys = new Set(["ok", "success", "status", "result", "error", "message"]);
+        if ([...lowerKeys].every(k => trivialKeys.has(k))) {
+          if (Object.values(obj).every((v: any) => typeof v === "boolean" || v === null || (typeof v === "string" && v.length < 20))) {
+            return true;
+          }
+        }
+      }
+    }
+  } catch { /* not JSON */ }
+  return false;
+}
+
 export class IngestWorker {
   private summarizer: Summarizer;
   private taskProcessor: TaskProcessor;
@@ -30,7 +64,14 @@ export class IngestWorker {
   }
 
   enqueue(messages: ConversationMessage[]): void {
-    const filtered = messages.filter((m) => !IngestWorker.isEphemeralSession(m.sessionKey));
+    const filtered = messages.filter((m) => {
+      if (IngestWorker.isEphemeralSession(m.sessionKey)) return false;
+      if (isTrivialContent(m.content)) {
+        this.ctx.log.debug(`Skipping trivial content: ${m.content.slice(0, 80)}`);
+        return false;
+      }
+      return true;
+    });
     if (filtered.length === 0) return;
     this.queue.push(...filtered);
     if (!this.processing) {