Fix 4 product-quality issues: garbage rejection, ISO-8601, dedup, CLI fallback

1. Reject [object Object] garbage: lower threshold to 1, add check in
   extract no-LLM path, defensive serialization in Claude Code hooks,
   harden _asText in cursor-hooks for {text: "..."} wrapper pattern.

2. Accept ISO-8601 datetime in clickmem_list: normalize T separator,
   trailing Z, and timezone offsets before building SQL.

3. Deduplicate exact-text semantic memories: add _dedup_exact_text()
   to ContinualRefinement.run(), proactive dedup in extractor before
   insert.

4. CLI local fallback: add --local flag, auto-fallback to LocalTransport
   only when no remote config exists (respects CLICKMEM_SERVER_HOST).

Author: auxten

cursor-hooks/lib/handlers.js

@@ -24,6 +24,7 @@ function _log(msg) {
 function _asText(val) {
   if (val === null || val === undefined) return "";
   if (typeof val === "string") return val;
+  if (typeof val === "object" && !Array.isArray(val) && typeof val.text === "string") return val.text;
   if (Array.isArray(val)) return val.map(_asText).join("\n");
   return JSON.stringify(val);
 }

src/memory_core/cli.py

@@ -35,6 +35,7 @@
 
 _remote_url: str | None = None
 _remote_api_key: str | None = None
+_force_local: bool = False
 
 
 @app.callback()
@@ -47,10 +48,15 @@ def _global_options(
         None, "--api-key", envvar="CLICKMEM_API_KEY",
         help="API key for remote server authentication.",
     ),
+    local: bool = typer.Option(
+        False, "--local",
+        help="Use embedded database directly (no server needed).",
+    ),
 ):
-    global _remote_url, _remote_api_key
+    global _remote_url, _remote_api_key, _force_local
     _remote_url = remote
     _remote_api_key = api_key
+    _force_local = local
 
 
 # ---------------------------------------------------------------------------
@@ -60,11 +66,31 @@ def _global_options(
 _transport_instance = None
 
 
+def _has_remote_config() -> bool:
+    """Check if the user has explicitly configured a remote server."""
+    return bool(
+        _remote_url
+        or os.environ.get("CLICKMEM_REMOTE")
+        or os.environ.get("CLICKMEM_SERVER_HOST")
+    )
+
+
 def _get_transport():
     global _transport_instance
     if _transport_instance is None:
-        from memory_core.transport import get_transport
-        _transport_instance = get_transport(remote=_remote_url, api_key=_remote_api_key)
+        if _force_local:
+            from memory_core.transport import LocalTransport
+            _transport_instance = LocalTransport()
+        else:
+            from memory_core.transport import get_transport
+            try:
+                _transport_instance = get_transport(remote=_remote_url, api_key=_remote_api_key)
+            except RuntimeError:
+                if _has_remote_config():
+                    raise
+                print("[clickmem] No server found, using local database.", file=sys.stderr)
+                from memory_core.transport import LocalTransport
+                _transport_instance = LocalTransport()
     return _transport_instance
 
 

src/memory_core/db.py

@@ -295,6 +295,19 @@ def optimize(self) -> None:
 
     # -- Queries -----------------------------------------------------------
 
+    @staticmethod
+    def _normalize_datetime(dt_str: str) -> str:
+        """Normalize ISO-8601 datetime to ClickHouse-compatible format.
+
+        Handles 'T' separator, trailing 'Z', and timezone offsets like +00:00.
+        """
+        import re
+        s = dt_str.replace("T", " ")
+        if s.endswith("Z"):
+            s = s[:-1]
+        s = re.sub(r'[+-]\d{2}:?\d{2}$', '', s)
+        return s.strip()
+
     def _time_conditions(self, since: str | None, until: str | None) -> list[str]:
         """Build SQL WHERE clauses for time filtering.
 
@@ -304,9 +317,11 @@ def _time_conditions(self, since: str | None, until: str | None) -> list[str]:
         _dt_re = re.compile(r"^\d{4}-\d{2}-\d{2}[\sT]?\d{0,2}:?\d{0,2}:?\d{0,2}")
         conds: list[str] = []
         if since and _dt_re.match(since):
-            conds.append(f"created_at >= '{self._escape(since)}'")
+            normalized = self._normalize_datetime(since)
+            conds.append(f"created_at >= '{self._escape(normalized)}'")
         if until and _dt_re.match(until):
-            conds.append(f"created_at <= '{self._escape(until)}'")
+            normalized = self._normalize_datetime(until)
+            conds.append(f"created_at <= '{self._escape(normalized)}'")
         return conds
 
     def list_by_layer(self, layer: str, *, limit: int = 100,

src/memory_core/extractor.py

@@ -66,7 +66,7 @@ def extract(
         conversation = "\n".join(
             f"{m.get('role', 'user')}: {m.get('content', '')}" for m in messages
         )
-        if conversation.count("[object Object]") >= 2:
+        if "[object Object]" in conversation:
             return []
         prompt = _EXTRACT_PROMPT.format(conversation=conversation)
         raw_response = llm_complete(prompt)
@@ -82,13 +82,21 @@ def extract(
                     ids.append(rows[0].id)
                 continue
 
+            content = mem_data.get("content", "")
+            # Proactive dedup: skip if identical content already exists in this layer
+            existing = self._db.list_by_layer(layer, limit=100)
+            dup = next((e for e in existing if e.content.strip().lower() == content.strip().lower()), None)
+            if dup:
+                ids.append(dup.id)
+                continue
+
             m = Memory(
-                content=mem_data.get("content", ""),
+                content=content,
                 layer=layer,
                 category=mem_data.get("category", "event"),
                 tags=mem_data.get("tags", []),
                 entities=mem_data.get("entities", []),
-                embedding=self._emb.encode_document(mem_data.get("content", "")),
+                embedding=self._emb.encode_document(content),
                 session_id=session_id,
                 source="agent",
                 raw_id=raw_id or None,

src/memory_core/refinement.py

@@ -8,6 +8,7 @@
 
 import logging
 import math
+from datetime import datetime
 from typing import TYPE_CHECKING, Callable
 
 from memory_core.json_utils import extract_json_or
@@ -82,11 +83,13 @@ def run(
         llm_complete: Callable[[str], str],
     ) -> dict:
         _log.info("Starting continual refinement")
+        exact_deduped = ContinualRefinement._dedup_exact_text(db)
         reextracted = ContinualRefinement._reextract_unprocessed(db, emb, llm_complete)
         clusters = ContinualRefinement._cluster_semantic(db, emb)
         merged = ContinualRefinement._refine_clusters(db, emb, llm_complete, clusters)
         pruned = ContinualRefinement._prune_low_quality(db, llm_complete)
         result = {
+            "exact_deduped": exact_deduped,
             "reextracted": reextracted,
             "clusters_found": len(clusters),
             "merged": merged,
@@ -95,6 +98,27 @@ def run(
         _log.info("Refinement complete: %s", result)
         return result
 
+    @staticmethod
+    def _dedup_exact_text(db: "MemoryDB") -> int:
+        """Remove exact-text duplicates in the semantic layer.
+
+        Keeps the oldest memory (by created_at) and deactivates newer copies.
+        """
+        memories = db.list_by_layer("semantic", limit=500)
+        content_groups: dict[str, list[Memory]] = {}
+        for m in memories:
+            key = m.content.strip().lower()
+            content_groups.setdefault(key, []).append(m)
+        deduped = 0
+        for group in content_groups.values():
+            if len(group) < 2:
+                continue
+            group.sort(key=lambda m: m.created_at or datetime.min)
+            for dup in group[1:]:
+                db.deactivate(dup.id)
+                deduped += 1
+        return deduped
+
     @staticmethod
     def _reextract_unprocessed(
         db: "MemoryDB", emb, llm_complete: Callable[[str], str],

src/memory_core/server.py

@@ -366,6 +366,9 @@ async def _cc_user_prompt_submit(payload: dict) -> dict:
     """Buffer the user prompt so the Stop handler can build the full turn."""
     session_id = payload.get("session_id", "")
     prompt = payload.get("prompt", "")
+    if not isinstance(prompt, str):
+        import json as _json
+        prompt = _json.dumps(prompt, ensure_ascii=False) if prompt else ""
     if session_id and prompt:
         _cc_prompt_buffers[session_id] = prompt
     return {}
@@ -375,6 +378,9 @@ async def _cc_stop(payload: dict) -> dict:
     """Extract memories from the completed turn (buffered prompt + assistant response)."""
     session_id = payload.get("session_id", "")
     assistant_msg = payload.get("last_assistant_message", "")
+    if not isinstance(assistant_msg, str):
+        import json as _json
+        assistant_msg = _json.dumps(assistant_msg, ensure_ascii=False) if assistant_msg else ""
 
     if not assistant_msg or len(assistant_msg) < 20:
         return {}

src/memory_core/transport.py

@@ -143,6 +143,8 @@ def extract(self, text: str, session_id: str = "") -> list[str]:
         llm_complete = get_llm_complete()
 
         if llm_complete is None:
+            if "[object Object]" in text:
+                return []
             m = Memory(
                 content=text, layer="episodic", category="event",
                 embedding=emb.encode_document(text),
@@ -158,7 +160,7 @@ def extract(self, text: str, session_id: str = "") -> list[str]:
             llm_complete, session_id=session_id,
         )
 
-    _GARBAGE_PATTERN_THRESHOLD = 2
+    _GARBAGE_PATTERN_THRESHOLD = 1
 
     def ingest(self, text: str, session_id: str = "",
                source: str = "cursor") -> dict:

tests/conftest.py

@@ -144,6 +144,7 @@ def _reset_factory():
     cli_mod._transport_instance = shared_t
     cli_mod._remote_url = None
     cli_mod._remote_api_key = None
+    cli_mod._force_local = False
     import memory_core.server as server_mod
     server_mod._transport = None
     server_mod._api_key_env = None

tests/test_cli.py

@@ -253,6 +253,33 @@ def test_sql_invalid_query(self):
         assert result.exit_code != 0 or "error" in result.stdout.lower()
 
 
+class TestLocalFallback:
+    """Test --local flag and auto-fallback behavior."""
+
+    def test_local_flag_status(self):
+        """memory --local status works without a running server."""
+        result = runner.invoke(app, ["--local", "status"])
+        assert result.exit_code == 0
+        output = result.stdout.lower()
+        assert "working" in output or "l0" in output
+
+    def test_local_flag_status_json(self):
+        """memory --local status --json returns valid JSON."""
+        result = runner.invoke(app, ["--local", "status", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.stdout)
+        assert isinstance(data, dict)
+        assert "counts" in data
+
+    def test_auto_fallback_when_no_server(self):
+        """Without --remote and without a server, CLI auto-falls back to local."""
+        import memory_core.cli as cli_mod
+        cli_mod._transport_instance = None
+        cli_mod._force_local = False
+        result = runner.invoke(app, ["status"])
+        assert result.exit_code == 0
+
+
 class TestMaintainCommand:
     """Test `memory maintain` command."""
 

tests/test_db.py

@@ -463,6 +463,56 @@ def test_skips_empty_embeddings(self, db, mock_emb):
         assert all(len(r.embedding) > 0 for r in results)
 
 
+class TestTimeConditionsISO8601:
+    """Test ISO-8601 datetime parsing in _time_conditions."""
+
+    def test_iso8601_with_t_and_z(self, db):
+        """since='2026-03-13T00:00:00Z' should be accepted and normalized."""
+        m = make_memory(
+            layer="semantic",
+            created_at=datetime(2026, 3, 14, tzinfo=timezone.utc),
+        )
+        db.insert(m)
+        results = db.list_memories(since="2026-03-13T00:00:00Z")
+        assert len(results) == 1
+
+    def test_iso8601_with_timezone_offset(self, db):
+        """since='2026-03-13T00:00:00+00:00' should be accepted."""
+        m = make_memory(
+            layer="semantic",
+            created_at=datetime(2026, 3, 14, tzinfo=timezone.utc),
+        )
+        db.insert(m)
+        results = db.list_memories(since="2026-03-13T00:00:00+00:00")
+        assert len(results) == 1
+
+    def test_iso8601_until_with_t_and_z(self, db):
+        """until='2026-03-15T00:00:00Z' should be accepted."""
+        m = make_memory(
+            layer="semantic",
+            created_at=datetime(2026, 3, 14, tzinfo=timezone.utc),
+        )
+        db.insert(m)
+        results = db.list_memories(until="2026-03-15T00:00:00Z")
+        assert len(results) == 1
+
+    def test_plain_datetime_still_works(self, db):
+        """Plain 'YYYY-MM-DD HH:MM:SS' format should still work."""
+        m = make_memory(
+            layer="semantic",
+            created_at=datetime(2026, 3, 14, tzinfo=timezone.utc),
+        )
+        db.insert(m)
+        results = db.list_memories(since="2026-03-13 00:00:00")
+        assert len(results) == 1
+
+    def test_normalize_datetime_static(self, db):
+        """_normalize_datetime properly converts ISO-8601 variants."""
+        assert db._normalize_datetime("2026-03-13T00:00:00Z") == "2026-03-13 00:00:00"
+        assert db._normalize_datetime("2026-03-13T10:30:00+05:30") == "2026-03-13 10:30:00"
+        assert db._normalize_datetime("2026-03-13 12:00:00") == "2026-03-13 12:00:00"
+
+
 class TestRawQuery:
     """Test raw SQL query execution."""