superlocalmemory 3.8.5 → 3.8.7

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

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from fastapi import APIRouter, HTTPException, Query, Request
 
-from .helpers import get_active_profile, require_engine
+from .helpers import get_active_profile, get_read_connection, require_engine
 
 router = APIRouter(prefix="/api/entity", tags=["entity"])
 
@@ -82,9 +82,7 @@ def list_entities(
     profile = profile or get_active_profile()
     _require_read(request, profile)
 
-    import sqlite3
-    conn = sqlite3.connect(str(engine._config.db_path))
-    conn.row_factory = sqlite3.Row
+    conn = get_read_connection(engine._config.db_path)
     try:
         where = ["ce.profile_id = ?"]
         params: list[object] = [profile]
@@ -158,9 +156,7 @@ def get_entity(
     _require_read(request, profile)
 
     import json
-    import sqlite3
-    conn = sqlite3.connect(str(engine._config.db_path))
-    conn.row_factory = sqlite3.Row
+    conn = get_read_connection(engine._config.db_path)
     try:
         # Search by canonical_name (case-insensitive)
         row = conn.execute("""

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

@@ -15,6 +15,7 @@ from fastapi import APIRouter, Request
 from pydantic import BaseModel
 
 from superlocalmemory.server.config_file import read_config, update_config
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 
 from .helpers import MEMORY_DIR, get_active_profile
 
@@ -261,12 +262,9 @@ def evolution_lineage(request: Request, skill_name: str = ""):
     _require_read(request)
     conn = None
     try:
-        import sqlite3 as _sqlite3
-
-        db_path = str(MEMORY_DIR / "memory.db")
+        db_path = MEMORY_DIR / "memory.db"
         profile_id = get_active_profile()
-        conn = _sqlite3.connect(db_path, timeout=10)
-        conn.row_factory = _sqlite3.Row
+        conn = ReadConnectionFactory(db_path).open()
 
         if skill_name:
             rows = conn.execute(

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

@@ -22,7 +22,7 @@ from fastapi import HTTPException, Request
 from pydantic import BaseModel, Field
 
 from superlocalmemory.infra.data_root import DynamicStatePath, canonical_data_root
-from superlocalmemory.storage.memory_write import memory_write
+from superlocalmemory.storage.memory_write import memory_read, memory_write
 
 
 _engine_logger = logging.getLogger("superlocalmemory.engine")
@@ -217,24 +217,48 @@ def log_mode_change(
     )
 
 
-def get_db_connection() -> sqlite3.Connection:
-    """Get database connection with busy_timeout set.
+class _RouteReadConnection:
+    """Compatibility wrapper for legacy route callers that close manually.
 
-    Used for READ-heavy callers. Writers should use ``memory_write(DB_PATH)``
-    instead to also acquire the process write lock.  This connection still gets
-    ``PRAGMA busy_timeout`` so a cross-process writer (hook / CLI) doing a short
-    write does not cause an immediate SQLITE_BUSY here.
+    New routes should prefer ``with memory_read(path)``.  A few shared route
+    callers still expect ``get_db_connection()`` to return a connection they
+    can close themselves, so this wrapper preserves that contract without
+    reopening canonical ``memory.db`` in writable mode.
     """
-    if not DB_PATH.exists():
+
+    def __init__(self, db_path: Path) -> None:
+        object.__setattr__(self, "_snapshot", memory_read(db_path))
+        object.__setattr__(self, "_connection", self._snapshot.__enter__())
+        object.__setattr__(self, "_closed", False)
+
+    def __getattr__(self, name: str):
+        return getattr(self._connection, name)
+
+    def __setattr__(self, name: str, value) -> None:
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._connection, name, value)
+
+    def close(self) -> None:
+        if not self._closed:
+            self._snapshot.__exit__(None, None, None)
+            object.__setattr__(self, "_closed", True)
+
+
+def get_read_connection(db_path: Path = DB_PATH) -> _RouteReadConnection:
+    """Return a legacy-compatible, physically read-only canonical connection."""
+    if not db_path.exists():
         raise HTTPException(
             status_code=500,
-            detail="Memory database not found. Run 'slm init' to initialize."
+            detail="Memory database not found. Run 'slm init' to initialize.",
         )
-    import os as _os
-    _ms = max(0, int(_os.environ.get("SLM_DB_BUSY_TIMEOUT_MS", "10000")))
-    conn = sqlite3.connect(str(DB_PATH), timeout=_ms / 1000.0)
-    conn.execute(f"PRAGMA busy_timeout={_ms}")
-    return conn
+    return _RouteReadConnection(db_path)
+
+
+def get_db_connection() -> _RouteReadConnection:
+    """Return the shared dashboard read connection for canonical ``memory.db``."""
+    return get_read_connection(DB_PATH)
 
 
 def dict_factory(cursor: sqlite3.Cursor, row: tuple) -> dict:
@@ -380,18 +404,15 @@ def _get_db_profiles() -> list[dict]:
     """Read all profiles from SQLite."""
     if not DB_PATH.exists():
         return []
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
     try:
-        rows = conn.execute(
-            "SELECT profile_id, name, description, created_at, last_used "
-            "FROM profiles ORDER BY name"
-        ).fetchall()
-        return [dict(r) for r in rows]
+        with memory_read(DB_PATH) as conn:
+            rows = conn.execute(
+                "SELECT profile_id, name, description, created_at, last_used "
+                "FROM profiles ORDER BY name"
+            ).fetchall()
+            return [dict(r) for r in rows]
     except sqlite3.OperationalError:
         return []
-    finally:
-        conn.close()
 
 
 def _load_profiles_json() -> dict:

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

@@ -17,7 +17,7 @@ from typing import Any, Callable
 
 from fastapi import APIRouter, Query
 from fastapi.responses import JSONResponse
-from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile
+from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile, get_read_connection
 
 logger = logging.getLogger(__name__)
 
@@ -31,9 +31,7 @@ def _get_conn(profile: str = "") -> tuple[sqlite3.Connection | None, str]:
     pid = profile or get_active_profile()
     if not DB_PATH.exists():
         return None, pid
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
-    return conn, pid
+    return get_read_connection(DB_PATH), pid
 
 
 # ── Action Handlers ───────────────────────────────────────────────

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

@@ -12,7 +12,6 @@ Uses V3 learning modules: FeedbackCollector, EngagementTracker, AdaptiveLearner.
 import logging
 import shutil
 import sqlite3
-from contextlib import closing
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -30,6 +29,7 @@ from .learning_telemetry import (
 from .learning_telemetry import (
     sqlite_status as _sqlite_status,
 )
+from superlocalmemory.storage.memory_write import memory_read
 
 logger = logging.getLogger("superlocalmemory.routes.learning")
 router = APIRouter()
@@ -667,12 +667,9 @@ def get_patterns():
 
     # Graph intelligence contribution to learning (v3.4.1)
     try:
-        import sqlite3 as _sqlite3
-
         from superlocalmemory.server.routes.helpers import DB_PATH
         if DB_PATH.exists():
-            with closing(_sqlite3.connect(str(DB_PATH))) as conn:
-                conn.row_factory = _sqlite3.Row
+            with memory_read(DB_PATH) as conn:
                 row = conn.execute(
                     "SELECT COUNT(*) AS cnt, "
                     "COUNT(DISTINCT community_id) AS communities, "

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

@@ -7,13 +7,12 @@
 Routes: /api/lifecycle/status, /api/lifecycle/compact
 Uses V3 compliance.lifecycle.LifecycleManager.
 """
-import json
 import logging
 import sqlite3
 
 from fastapi import APIRouter, Request
 
-from .helpers import get_active_profile, get_engine_lazy, MEMORY_DIR, DB_PATH
+from .helpers import DB_PATH, get_active_profile, get_engine_lazy, get_read_connection
 from superlocalmemory.server.route_mutations import authorize_route_mutation
 
 logger = logging.getLogger("superlocalmemory.routes.lifecycle")
@@ -36,8 +35,7 @@ async def lifecycle_status():
 
     try:
         profile = get_active_profile()
-        conn = sqlite3.connect(str(DB_PATH))
-        conn.row_factory = sqlite3.Row
+        conn = get_read_connection(DB_PATH)
 
         # V3.3: Use fact_retention.lifecycle_zone (Ebbinghaus-driven, authoritative)
         # Falls back to atomic_facts.lifecycle for pre-3.3 databases

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

@@ -7,18 +7,23 @@ Uses V3 MemoryEngine for store/recall. Falls back to direct DB for list/graph.
 """
 import json
 import logging
+import re
+import uuid
 from typing import Optional
 
 from fastapi import APIRouter, HTTPException, Query, Request
 
 from .helpers import (
-    get_db_connection, dict_factory, get_active_profile, get_engine_lazy,
-    SearchRequest, DB_PATH, MEMORY_DIR,
+    SearchRequest,
+    dict_factory,
+    get_active_profile,
+    get_db_connection,
+    get_engine_lazy,
 )
-from superlocalmemory.storage.memory_write import memory_write
 
 logger = logging.getLogger("superlocalmemory.routes.memories")
 router = APIRouter()
+_IDEMPOTENCY_KEY = re.compile(r"^[A-Za-z0-9._:-]{1,256}$")
 
 # v3.8.3: GENEROUS latency budget for recall. SLM's value is quality recall
 # under heavy multi-agent load, so semantic recall is given ample time to
@@ -57,6 +62,58 @@ def _get_engine(request: Request):
     return get_engine_lazy(request.app.state)
 
 
+def _canonical_mutation_runtime(request: Request):
+    """Return the daemon-owned mutation boundary or fail before queueing work."""
+    runtime = getattr(request.app.state, "canonical_remember_runtime", None)
+    if runtime is None or not runtime.ready:
+        raise HTTPException(503, detail="canonical mutation writer is not ready; retry shortly")
+    return runtime
+
+
+def _mutation_idempotency_key(request: Request) -> str:
+    """Accept a client retry key without making one mandatory for the dashboard."""
+    key = request.headers.get("X-Idempotency-Key", "").strip() or str(uuid.uuid4())
+    if not _IDEMPOTENCY_KEY.fullmatch(key):
+        raise HTTPException(
+            422,
+            detail="X-Idempotency-Key must contain 1-256 safe characters",
+        )
+    return key
+
+
+def _canonical_mutation_error(exc: Exception, detail: str) -> HTTPException:
+    """Map typed mutation failures without leaking SQLite or filesystem detail."""
+    from superlocalmemory.core.remember_runtime import (
+        CanonicalMutationConflict,
+        CanonicalRememberUnavailable,
+    )
+
+    if isinstance(exc, CanonicalMutationConflict):
+        return HTTPException(409, detail=str(exc))
+    if isinstance(exc, CanonicalRememberUnavailable):
+        return HTTPException(
+            503,
+            detail="canonical mutation writer is temporarily unavailable",
+        )
+    return _internal_error(detail)
+
+
+def _mutation_runtime_or_missing_fact(
+    request: Request, engine, profile_id: str, fact_id: str,
+):
+    """Retain the public 404 for a missing fact without creating a local writer."""
+    runtime = getattr(request.app.state, "canonical_remember_runtime", None)
+    if runtime is not None and runtime.ready:
+        return runtime
+    rows = engine._db.execute(
+        "SELECT 1 FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
+        (fact_id, profile_id),
+    )
+    if not rows:
+        raise HTTPException(status_code=404, detail="Memory not found")
+    raise HTTPException(503, detail="canonical mutation writer is not ready; retry shortly")
+
+
 def _authorize_memory_mutation(
     request: Request,
     operation: str,
@@ -726,13 +783,21 @@ async def get_clusters(request: Request):
                 unclustered = 0
 
         conn.close()
-        return {"clusters": clusters, "total_clusters": len(clusters), "unclustered_count": unclustered}
+        return {
+            "clusters": clusters,
+            "total_clusters": len(clusters),
+            "unclustered_count": unclustered,
+        }
     except Exception:
         raise _internal_error("Cluster error")
 
 
 @router.get("/api/clusters/{cluster_id}")
-async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Query(50, ge=1, le=200)):
+async def get_cluster_detail(
+    request: Request,
+    cluster_id: str,
+    limit: int = Query(50, ge=1, le=200),
+):
     """Get detailed view of a specific cluster (scene)."""
     try:
         conn = get_db_connection()
@@ -974,14 +1039,18 @@ async def delete_memory(request: Request, fact_id: str):
             fact_id,
             trusted_actor_id=hook_context["agent_id"],
             source_agent_id="dashboard",
+            canonical_runtime=_mutation_runtime_or_missing_fact(
+                request, engine, _active_profile, fact_id,
+            ),
+            idempotency_key=_mutation_idempotency_key(request),
         )
         if not result.get("ok"):
             raise HTTPException(status_code=404, detail="Memory not found")
         return {"success": True, "deleted": fact_id}
     except HTTPException:
         raise
-    except Exception:
-        raise _internal_error("Delete error")
+    except Exception as exc:
+        raise _canonical_mutation_error(exc, "Delete error")
 
 
 @router.post("/api/memories/{fact_id}/forget")
@@ -993,54 +1062,25 @@ async def forget_memory(request: Request, fact_id: str):
     The fact's payload is ALSO copied into ``memory_archive`` so a
     future ``slm restore`` can bring it back.
     """
-    import json as _json
     engine, active_profile, hook_context = _authorize_memory_mutation(
         request, "delete", fact_id,
+        run_pre_hook=False,
     )
     try:
-        from datetime import datetime, timezone
-        import uuid as _uuid
-        archived_at = datetime.now(timezone.utc).isoformat()
-        archive_id = str(_uuid.uuid4())
-        # memory_write: write lock (in-process) + busy_timeout (cross-process).
-        # SELECT + INSERT + UPDATE are atomic inside the same connection.
-        with memory_write(DB_PATH) as conn:
-            conn.row_factory = dict_factory
-            row = conn.execute(
-                "SELECT fact_id, content, importance, confidence, "
-                "       canonical_entities_json, embedding, created_at "
-                "FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
-                (fact_id, active_profile),
-            ).fetchone()
-            if not row:
-                raise HTTPException(status_code=404, detail="Memory not found")
-            # Archive copy — payload_json small enough for the canonical row.
-            payload = {
-                "fact_id": row["fact_id"],
-                "content": row["content"],
-                "canonical_entities_json": row.get("canonical_entities_json"),
-                "importance": row.get("importance"),
-                "confidence": row.get("confidence"),
-                "created_at": row.get("created_at"),
-            }
-            conn.execute(
-                "INSERT INTO memory_archive "
-                "(archive_id, fact_id, profile_id, payload_json, archived_at, reason) "
-                "VALUES (?, ?, ?, ?, ?, ?)",
-                (archive_id, fact_id, active_profile,
-                 _json.dumps(payload), archived_at, "user_forget_dashboard"),
-            )
-            conn.execute(
-                "UPDATE atomic_facts SET archive_status = 'archived' "
-                "WHERE fact_id = ?",
-                (fact_id,),
-            )
+        engine._hooks.run_pre("delete", hook_context)
+        result = _canonical_mutation_runtime(request).archive_fact(
+            active_profile,
+            fact_id,
+            idempotency_key=_mutation_idempotency_key(request),
+        )
+        if not result.get("ok"):
+            raise HTTPException(status_code=404, detail="Memory not found")
         engine._hooks.run_post("delete", hook_context)
-        return {"success": True, "fact_id": fact_id, "archived_at": archived_at}
+        return {"success": True, "fact_id": fact_id, "archived_at": result["archived_at"]}
     except HTTPException:
         raise
-    except Exception:
-        raise _internal_error("Forget error")
+    except Exception as exc:
+        raise _canonical_mutation_error(exc, "Forget error")
 
 
 @router.post("/api/memories/{fact_id}/merge")
@@ -1055,6 +1095,7 @@ async def merge_memory(request: Request, fact_id: str):
     """
     engine, active_profile, hook_context = _authorize_memory_mutation(
         request, "delete", fact_id,
+        run_pre_hook=False,
     )
     try:
         body = await request.json()
@@ -1066,50 +1107,26 @@ async def merge_memory(request: Request, fact_id: str):
             raise HTTPException(400, "'into' exceeds 200-char limit")
         if kept == fact_id:
             raise HTTPException(400, "Cannot merge a fact into itself")
-        from datetime import datetime, timezone
-        merged_at = datetime.now(timezone.utc).isoformat()
-        # memory_write: write lock (in-process) + busy_timeout (cross-process).
-        # SELECT + INSERT + UPDATE are atomic inside the same connection.
-        with memory_write(DB_PATH) as conn:
-            conn.row_factory = dict_factory
-            # Both must belong to the active profile.
-            found = {
-                r["fact_id"]
-                for r in conn.execute(
-                    "SELECT fact_id FROM atomic_facts "
-                    "WHERE fact_id IN (?, ?) AND profile_id = ?",
-                    (fact_id, kept, active_profile),
-                ).fetchall()
-            }
-            if fact_id not in found or kept not in found:
-                raise HTTPException(
-                    404,
-                    "Both fact_ids must exist in the active profile",
-                )
-            conn.execute(
-                "INSERT INTO memory_merge_log "
-                "(kept_fact_id, merged_fact_id, profile_id, reason, merged_at) "
-                "VALUES (?, ?, ?, ?, ?)",
-                (kept, fact_id, active_profile,
-                 "user_merge_dashboard", merged_at),
-            )
-            conn.execute(
-                "UPDATE atomic_facts "
-                "SET merged_into = ?, archive_status = 'archived' "
-                "WHERE fact_id = ?",
-                (kept, fact_id),
-            )
+        engine._hooks.run_pre("delete", hook_context)
+        result = _canonical_mutation_runtime(request).merge_fact(
+            active_profile,
+            fact_id,
+            kept,
+            idempotency_key=_mutation_idempotency_key(request),
+        )
+        if not result.get("ok"):
+            raise HTTPException(404, "Both fact_ids must exist in the active profile")
         engine._hooks.run_post("delete", hook_context)
         return {
             "success": True,
             "merged": fact_id,
             "into": kept,
-            "merged_at": merged_at,
+            "merged_at": result["merged_at"],
         }
     except HTTPException:
         raise
-    except Exception:
-        raise _internal_error("Merge error")
+    except Exception as exc:
+        raise _canonical_mutation_error(exc, "Merge error")
 
 
 @router.patch("/api/memories/{fact_id}")
@@ -1135,14 +1152,16 @@ async def edit_memory(request: Request, fact_id: str):
             new_content,
             trusted_actor_id=hook_context["agent_id"],
             source_agent_id="dashboard",
+            canonical_runtime=_canonical_mutation_runtime(request),
+            idempotency_key=_mutation_idempotency_key(request),
         )
         if not result.get("ok"):
             raise HTTPException(status_code=404, detail="Memory not found")
         return {"success": True, "fact_id": fact_id, "content": new_content}
     except HTTPException:
         raise
-    except Exception:
-        raise _internal_error("Edit error")
+    except Exception as exc:
+        raise _canonical_mutation_error(exc, "Edit error")
 
 
 _VALID_SCOPES = ("personal", "shared", "global")
@@ -1158,7 +1177,6 @@ async def set_memory_scope(request: Request, fact_id: str):
     belong to the active profile (a caller cannot re-scope another profile's
     fact). This is the write side of multi-scope sharing from the dashboard.
     """
-    import json as _json
     try:
         body = await request.json()
         scope = (body.get("scope") or "").strip().lower()
@@ -1179,26 +1197,30 @@ async def set_memory_scope(request: Request, fact_id: str):
         if scope != "shared":
             shared_list = []
 
-        engine, active_profile, _ctx = _authorize_memory_mutation(
+        engine, active_profile, hook_context = _authorize_memory_mutation(
             request, "update", fact_id, run_pre_hook=False,
         )
-        # Ownership check: the fact must belong to the active profile.
-        rows = engine._db.execute(
-            "SELECT 1 FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
-            (fact_id, active_profile),
+        if scope in {"shared", "global"}:
+            from superlocalmemory.access.rbac import Permission
+            from superlocalmemory.server.rbac_enforce import require_permission
+
+            require_permission(request, Permission.SHARE, profile=active_profile)
+        engine._hooks.run_pre("update", hook_context)
+        result = _canonical_mutation_runtime(request).set_fact_scope(
+            active_profile,
+            fact_id,
+            scope,
+            shared_list,
+            idempotency_key=_mutation_idempotency_key(request),
         )
-        if not rows:
+        if not result.get("ok"):
             raise HTTPException(404, detail="Memory not found in this profile")
-
-        engine._db.update_fact(fact_id, {
-            "scope": scope,
-            "shared_with": _json.dumps(shared_list),
-        }, profile_id=active_profile)
+        engine._hooks.run_post("update", hook_context)
         return {
             "success": True, "fact_id": fact_id, "scope": scope,
             "shared_with": shared_list, "active_profile": active_profile,
         }
     except HTTPException:
         raise
-    except Exception:
-        raise _internal_error("Scope update error")
+    except Exception as exc:
+        raise _canonical_mutation_error(exc, "Scope update error")

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

@@ -10,7 +10,6 @@ All connections use WAL mode + busy_timeout for concurrency safety.
 """
 
 import logging
-import os
 import re
 import sqlite3
 from contextlib import contextmanager
@@ -20,7 +19,7 @@ from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
 
 from superlocalmemory.server.route_mutations import authorize_route_mutation
-from superlocalmemory.storage.memory_write import memory_write
+from superlocalmemory.storage.memory_write import memory_read, memory_write
 
 from .helpers import DB_PATH, get_active_profile
 
@@ -36,29 +35,11 @@ class PinRequest(BaseModel):
     reason: str = Field(default="", max_length=_MAX_REASON_LENGTH)
 
 
-def _busy_ms() -> int:
-    try:
-        return max(0, int(os.environ.get("SLM_DB_BUSY_TIMEOUT_MS", "10000")))
-    except (TypeError, ValueError):
-        return 10000
-
-
 @contextmanager
 def _db():
-    """Context-managed DB connection with WAL + busy_timeout (READ paths only).
-
-    Write paths (pin, unpin) use ``memory_write()`` directly to also acquire
-    the process write lock and prevent in-process SQLITE_BUSY races.
-    """
-    ms = _busy_ms()
-    conn = sqlite3.connect(str(DB_PATH), timeout=ms / 1000.0)
-    conn.execute("PRAGMA journal_mode=WAL")
-    conn.execute(f"PRAGMA busy_timeout={ms}")
-    conn.row_factory = sqlite3.Row
-    try:
+    """Yield a short-lived query-only snapshot for tier dashboard reads."""
+    with memory_read(DB_PATH) as conn:
         yield conn
-    finally:
-        conn.close()
 
 
 def _validate_profile(profile_id: str) -> str:

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

@@ -13,11 +13,10 @@ from __future__ import annotations
 import logging
 import re
 import sqlite3
-from typing import Any
 
 from fastapi import APIRouter, Query
 from fastapi.responses import JSONResponse
-from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile
+from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile, get_read_connection
 
 logger = logging.getLogger(__name__)
 
@@ -65,8 +64,7 @@ async def get_timeline(
     if not DB_PATH.exists():
         return {"range": range, "group_by": group_by, "count": 0, "events": [], "total_available": 0, "offset": 0}
 
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
+    conn = get_read_connection(DB_PATH)
 
     try:
         start_date = conn.execute("SELECT datetime('now', ?)", (modifier,)).fetchone()[0]