superlocalmemory 3.8.8 → 3.8.10

package/src/superlocalmemory/core/ingestion_command.py

@@ -22,6 +22,7 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any, Callable
 
+from superlocalmemory.core.materialization_control import MaterializationDeferred
 from superlocalmemory.storage.database import DatabaseManager
 
 logger = logging.getLogger("superlocalmemory.ingestion_command")
@@ -606,6 +607,31 @@ class IngestionOperationRepository:
                 ) from exc
         return self._from_row(rows[0])
 
+    def defer_enriching(
+        self,
+        operation_id: str,
+        *,
+        owner: str,
+    ) -> IngestionOperation:
+        """Release a transition-preempted lease without consuming a retry.
+
+        Queryable evidence remains durable.  The compare-and-swap owner check
+        prevents a stale worker from requeueing work that another process has
+        already reclaimed.
+        """
+        rows = self.db.execute(
+            "UPDATE ingestion_operations SET state='queryable', "
+            "lease_owner='', lease_expires_at=0, next_retry_at=0, "
+            "attempt_count=CASE WHEN attempt_count > 0 THEN attempt_count - 1 ELSE 0 END, "
+            "last_error='', updated_at=strftime('%Y-%m-%dT%H:%M:%fZ', 'now') "
+            "WHERE operation_id=? AND state='enriching' AND lease_owner=? "
+            "RETURNING *",
+            (operation_id, owner),
+        )
+        if not rows:
+            raise InvalidStateTransition("enriching lease ownership was lost")
+        return self._from_row(rows[0])
+
     def reap_stuck_enriching(
         self,
         *,
@@ -936,6 +962,11 @@ class IngestionCommand:
                 )
         except LeaseLost:
             raise
+        except MaterializationDeferred:
+            return self.repository.defer_enriching(
+                operation_id,
+                owner=self._owner,
+            )
         except Exception as exc:
             return self.repository.finish_enriching(
                 operation_id,
@@ -983,6 +1014,11 @@ class IngestionCommand:
             )
         except LeaseLost:
             raise
+        except MaterializationDeferred:
+            return self.repository.defer_enriching(
+                operation.operation_id,
+                owner=self._owner,
+            )
         except Exception as exc:
             return self.repository.finish_enriching(
                 operation.operation_id,

package/src/superlocalmemory/core/materialization_control.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3
+
+"""Control-flow signals for best-effort materialization work.
+
+These exceptions deliberately live outside the ingestion state machine and
+embedding implementation so either layer can request a durable deferral
+without introducing an import cycle.
+"""
+
+from __future__ import annotations
+
+
+class MaterializationDeferred(RuntimeError):
+    """Best-effort enrichment yielded to a runtime transition.
+
+    The queryable projection is already durable.  This signal must be handled
+    by :class:`IngestionCommand` as a requeue, never as a failed attempt.
+    """

package/src/superlocalmemory/core/ollama_embedder.py

@@ -227,7 +227,7 @@ class OllamaEmbedder:
         data = resp.json()
         # Ollama /api/embed returns {"embeddings": [[...]]}
         vec = data["embeddings"][0]
-        return self._normalize(vec)
+        return self._normalize_checked(vec)
 
     def _call_ollama_embed_batch(self, texts: list[str]) -> list[list[float] | None]:
         """Call Ollama embed endpoint with batch input.
@@ -245,7 +245,16 @@ class OllamaEmbedder:
         resp.raise_for_status()
         data = resp.json()
         vectors = data.get("embeddings", [])
-        return [self._normalize(v) for v in vectors]
+        return [self._normalize_checked(v) for v in vectors]
+
+    def _normalize_checked(self, vec: list[float]) -> list[float]:
+        """Reject provider drift before a vector can enter any durable store."""
+        actual = len(vec)
+        if actual != self._dimension:
+            raise ValueError(
+                f"Ollama embedding dimension {actual} != expected {self._dimension}"
+            )
+        return self._normalize(vec)
 
     @staticmethod
     def _normalize(vec: list[float]) -> list[float]:

package/src/superlocalmemory/core/recall_gate.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 import threading
 from contextlib import contextmanager
-from typing import Iterator
+from typing import Callable, Iterator
 
 _condition = threading.Condition(threading.Lock())
 _active = 0
@@ -42,19 +42,30 @@ def in_flight() -> int:
 
 
 @contextmanager
-def background_work() -> Iterator[None]:
+def background_work(
+    *,
+    preempt_requested: Callable[[], bool] | None = None,
+) -> Iterator[None]:
     """Mark best-effort work that must yield shared inference to recall.
 
     The marker is thread-local because materialization, health probes, and
     interactive handlers all share one resident engine and one embedder.
-    Nested callers restore the previous marker on exit.
+    Nested callers restore the previous marker on exit.  A daemon-owned
+    materializer may also provide a preemption callback for a profile/runtime
+    reconfigure.  Inference clients use that callback to cut a bounded
+    background request short instead of holding the transition drain lease.
     """
     previous = bool(getattr(_work_context, "background", False))
+    previous_preempt = getattr(_work_context, "preempt_requested", None)
     _work_context.background = True
+    _work_context.preempt_requested = (
+        preempt_requested if preempt_requested is not None else previous_preempt
+    )
     try:
         yield
     finally:
         _work_context.background = previous
+        _work_context.preempt_requested = previous_preempt
 
 
 def is_background_work() -> bool:
@@ -62,6 +73,19 @@ def is_background_work() -> bool:
     return bool(getattr(_work_context, "background", False))
 
 
+def background_preempt_requested() -> bool:
+    """Return whether daemon-owned background work must release its lease."""
+    callback = getattr(_work_context, "preempt_requested", None)
+    if not callable(callback):
+        return False
+    try:
+        return bool(callback())
+    except Exception:
+        # A status read is advisory.  It must not crash a materializer or turn
+        # a valid recall into an ingestion failure.
+        return False
+
+
 def wait_for_foreground_idle() -> None:
     """Block background inference while an interactive recall is active."""
     if not is_background_work():

package/src/superlocalmemory/core/remember_admission.py

@@ -98,6 +98,7 @@ class RememberService:
         dispatched = self._journal.mark_dispatched(
             prepared.journal_id,
             deadline=deadline,
+            known_prepared=prepared.state == "prepared",
         )
         if dispatched.original_receipt is not None:
             return RememberReceipt.from_mapping(dispatched.original_receipt)
@@ -118,11 +119,19 @@ class RememberService:
         if state in {"committed", "duplicate"}:
             if not isinstance(receipt, Mapping):
                 raise AdmissionRejected("COMMAND_REJECTED: canonical result had no receipt")
-            committed = self._journal.mark_committed(
-                prepared.journal_id,
-                receipt,
-                deadline=deadline,
-            )
+            try:
+                committed = self._journal.mark_committed(
+                    prepared.journal_id,
+                    receipt,
+                    deadline=deadline,
+                )
+            except AdmissionJournalUnavailable:
+                # The canonical receipt is already durable and idempotent. Do
+                # not turn that committed write into an ambiguous client
+                # failure merely because the auxiliary journal exhausted the
+                # caller's remaining budget. The dispatched record is safe for
+                # retry/replay, which will recover the same immutable receipt.
+                return RememberReceipt.from_mapping(receipt)
             return RememberReceipt.from_mapping(committed.original_receipt or receipt)
 
         error_code = str(_result_value(result, "error_code") or "COMMAND_REJECTED")

package/src/superlocalmemory/core/store_pipeline.py

@@ -34,6 +34,14 @@ logger = logging.getLogger(__name__)
 _INIT_LANGEVIN_RADIUS = 0.05
 
 
+def _reraise_materialization_deferral(exc: Exception) -> None:
+    """Keep explicit runtime preemption out of best-effort fallbacks."""
+    from superlocalmemory.core.materialization_control import MaterializationDeferred
+
+    if isinstance(exc, MaterializationDeferred):
+        raise exc
+
+
 def _ingestion_effect_id(operation_id: str, *parts: object) -> str:
     """Return a stable ID for a relational effect owned by one ingestion."""
     if not operation_id:
@@ -247,6 +255,7 @@ def _upsert_fact_vectors(fact, profile_id, ann_index, vector_store, embedder=Non
         try:
             fact.embedding = embedder.embed(fact.content)
         except Exception as _emb_exc:  # pragma: no cover - defensive
+            _reraise_materialization_deferral(_emb_exc)
             logger.debug("on-demand embed failed for %s: %s", fact.fact_id, _emb_exc)
             return
     if not getattr(fact, "embedding", None):
@@ -429,6 +438,7 @@ def run_store(
         )
         extraction_complete = facts is not None
     except Exception as _extract_exc:
+        _reraise_materialization_deferral(_extract_exc)
         # P0-1 (remember-write-04): an extractor EXCEPTION (transient LLM/embed
         # backend error) must NOT orphan the already-committed memory. The None
         # guard below only handled a None *return*, not a raise. Treat a raise

package/src/superlocalmemory/hooks/adapter_base.py

@@ -26,7 +26,6 @@ from __future__ import annotations
 import hashlib
 import os
 import sqlite3
-import sys
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
@@ -76,8 +75,11 @@ class Adapter(Protocol):
 
 def path_sha256(path: Path) -> str:
     """SHA-256 of the absolute path string, full 64-hex (never truncated)."""
-    return hashlib.sha256(str(path.resolve() if path.exists()
-                              else path).encode("utf-8")).hexdigest()
+    # The identity must not depend on whether the target exists. On Windows,
+    # Path.resolve() can normalize an existing path differently from the same
+    # not-yet-created path, changing the sync-log key after the first write.
+    canonical = os.path.normcase(os.path.abspath(os.fspath(path)))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
 
 
 def _now_iso() -> str:
@@ -252,6 +254,11 @@ def atomic_write(
     flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
     if hasattr(os, "O_NOFOLLOW") and _is_posix():
         flags |= os.O_NOFOLLOW  # SEC — POSIX refuses symlinks
+    if hasattr(os, "O_BINARY") and not _is_posix():
+        # Windows file descriptors default to text mode, which rewrites LF
+        # bytes as CRLF.  The sync log hashes the caller's original bytes, so
+        # text-mode conversion makes an unchanged file look modified forever.
+        flags |= os.O_BINARY
 
     mode = posix_mode if _is_posix() else windows_mode
     fd = os.open(str(tmp), flags, mode)

package/src/superlocalmemory/mcp/tools_core.py

@@ -105,6 +105,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
         # recall window so a parallel/next agent finds memories saved seconds ago.
         # Falls back to the capability-owned worker only if the daemon is
         # unreachable. Raw pending.db writes are legacy replay input only.
+        daemon_owned = False
         try:
             import asyncio as _asyncio
             from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
@@ -159,6 +160,15 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 }
         except Exception as dexc:
             logger.debug("MCP remember via daemon failed, pending fallback: %s", dexc)
+            if daemon_owned:
+                return {
+                    "success": False,
+                    "code": "DAEMON_UNAVAILABLE",
+                    "retryable": True,
+                    "error": (
+                        "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later."
+                    ),
+                }
 
         try:
             import asyncio as _asyncio
@@ -174,11 +184,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     or "mcp:" + hashlib.sha256(content.encode("utf-8")).hexdigest()
                 ),
             }
-            stored = await _asyncio.to_thread(
-                choose_pool().store,
-                content,
-                worker_meta,
-            )
+
+            def _store_via_daemon_pool():
+                pool = choose_pool()
+                return pool.store(content, worker_meta)
+
+            stored = await _asyncio.to_thread(_store_via_daemon_pool)
             if not isinstance(stored, dict) or not stored.get("ok"):
                 if isinstance(stored, dict) and stored.get("code") == "DAEMON_UNAVAILABLE":
                     return {
@@ -282,7 +293,6 @@ def register_core_tools(server, get_engine: Callable) -> None:
         import asyncio
         try:
             from superlocalmemory.mcp._daemon_proxy import choose_pool
-            pool = choose_pool()
             # S9-DASH-10: priority for session_id, so engagement
             # signals land on the right pending_outcome:
             #   1. Explicit ``session_id`` tool-call argument.
@@ -322,15 +332,25 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     pass
             if not effective_sid:
                 effective_sid = f"mcp:{agent_id}"
-            # V3.3.19: Run in thread pool to avoid blocking MCP event loop.
+            # Resolve the daemon proxy inside the worker too. ``choose_pool``
+            # verifies daemon ownership through a synchronous /health request;
+            # when this tool is served by the daemon's mounted HTTP MCP app,
+            # resolving it on Uvicorn's event-loop thread makes that loop wait
+            # on its own health response forever. Stdio did not exhibit this
+            # because its MCP process is external to the daemon.
+            #
             # V3.4.26: WorkerPool now concurrent — parallel calls no longer
             # block behind a single threading.Lock. See worker_pool.py.
+            def _recall_via_daemon_pool():
+                pool = choose_pool()
+                return pool.recall(
+                    query, limit=limit, session_id=effective_sid,
+                    fast=fast, include_global=include_global,
+                    include_shared=include_shared, window=window or None,
+                )
+
             result = await asyncio.to_thread(
-                pool.recall, query, limit=limit, session_id=effective_sid,
-                fast=fast,
-                include_global=include_global,
-                include_shared=include_shared,
-                window=window or None,
+                _recall_via_daemon_pool,
             )
             if result.get("ok"):
                 return {

package/src/superlocalmemory/optimize/proxy/capture.py

@@ -74,7 +74,7 @@ def _windows_owner_dacl(
     win32api: Any,
     win32con: Any,
     win32security: Any,
-) -> Any:
+) -> tuple[Any, Any]:
     """Build one protected owner-only DACL for a Windows capture file."""
     import ntsecuritycon
 
@@ -95,7 +95,53 @@ def _windows_owner_dacl(
         ntsecuritycon.FILE_ALL_ACCESS,
         owner_sid,
     )
-    return dacl
+    return owner_sid, dacl
+
+
+def _windows_dacl_is_owner_only(
+    security_descriptor: Any,
+    owner_sid: Any,
+    ntsecuritycon: Any,
+    win32security: Any,
+) -> bool:
+    """Return whether a live descriptor already matches the capture policy."""
+    def _same_sid(left: Any, right: Any) -> bool:
+        try:
+            return (
+                win32security.ConvertSidToStringSid(left)
+                == win32security.ConvertSidToStringSid(right)
+            )
+        except Exception:
+            return False
+
+    control, _revision = security_descriptor.GetSecurityDescriptorControl()
+    if not control & win32security.SE_DACL_PROTECTED:
+        return False
+
+    descriptor_owner = security_descriptor.GetSecurityDescriptorOwner()
+    if descriptor_owner is None or not _same_sid(
+        descriptor_owner,
+        owner_sid,
+    ):
+        return False
+
+    dacl = security_descriptor.GetSecurityDescriptorDacl()
+    if dacl is None or dacl.GetAceCount() != 1:
+        return False
+
+    ace = dacl.GetAce(0)
+    if not isinstance(ace, tuple) or len(ace) != 3:
+        return False
+    ace_header, access_mask, ace_sid = ace
+    if (
+        not isinstance(ace_header, tuple)
+        or not ace_header
+        or ace_header[0] != win32security.ACCESS_ALLOWED_ACE_TYPE
+    ):
+        return False
+    if access_mask & ntsecuritycon.FILE_ALL_ACCESS != ntsecuritycon.FILE_ALL_ACCESS:
+        return False
+    return _same_sid(ace_sid, owner_sid)
 
 
 def _open_windows_capture_append(path: Path) -> int:
@@ -117,7 +163,11 @@ def _open_windows_capture_append(path: Path) -> int:
         # ever inheriting a broader parent DACL. For an existing file Windows
         # ignores this descriptor; _enforce_owner_only_permissions replaces
         # that DACL through the same WRITE_DAC-capable handle before writing.
-        dacl = _windows_owner_dacl(win32api, win32con, win32security)
+        owner_sid, dacl = _windows_owner_dacl(
+            win32api,
+            win32con,
+            win32security,
+        )
         security_attributes = win32security.SECURITY_ATTRIBUTES()
         security_attributes.bInheritHandle = False
         security_attributes.SECURITY_DESCRIPTOR.SetSecurityDescriptorDacl(
@@ -129,21 +179,57 @@ def _open_windows_capture_append(path: Path) -> int:
             win32security.SE_DACL_PROTECTED,
             win32security.SE_DACL_PROTECTED,
         )
-        handle = win32file.CreateFile(
-            os.fspath(path),
-            ntsecuritycon.FILE_APPEND_DATA | ntsecuritycon.WRITE_DAC,
+        desired_access = (
+            ntsecuritycon.FILE_APPEND_DATA
+            | ntsecuritycon.WRITE_DAC
+            | ntsecuritycon.READ_CONTROL
+        )
+        share_mode = (
             win32con.FILE_SHARE_READ
             | win32con.FILE_SHARE_WRITE
-            | win32con.FILE_SHARE_DELETE,
-            security_attributes,
-            win32con.OPEN_ALWAYS,
+            | win32con.FILE_SHARE_DELETE
+        )
+        file_flags = (
             win32con.FILE_ATTRIBUTE_NORMAL
             # pywin32 does not export this SDK constant from win32con on
             # every supported Python build. Keep the Microsoft-defined value
             # as a named fallback rather than silently following a reparse.
-            | getattr(win32con, "FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000),
-            None,
+            | getattr(win32con, "FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000)
         )
+        try:
+            # CREATE_NEW is the only race-safe proof that the protected
+            # SECURITY_ATTRIBUTES were applied to this exact file.  OPEN_ALWAYS
+            # would require trusting GetLastError after the pywin32 wrapper has
+            # returned, which is not a documented preservation boundary.
+            handle = win32file.CreateFile(
+                os.fspath(path),
+                desired_access,
+                share_mode,
+                security_attributes,
+                getattr(win32con, "CREATE_NEW", 1),
+                file_flags,
+                None,
+            )
+            created_new = True
+        except Exception as exc:
+            winerror = getattr(exc, "winerror", None)
+            if winerror is None and exc.args:
+                winerror = exc.args[0]
+            if winerror != getattr(win32con, "ERROR_FILE_EXISTS", 80):
+                raise
+            # The creation descriptor is ignored for existing files. Reopen
+            # the exact path without following a reparse point, then replace
+            # its DACL through this WRITE_DAC-capable handle before appending.
+            handle = win32file.CreateFile(
+                os.fspath(path),
+                desired_access,
+                share_mode,
+                None,
+                getattr(win32con, "OPEN_EXISTING", 3),
+                file_flags,
+                None,
+            )
+            created_new = False
         file_info = win32file.GetFileInformationByHandle(handle)
         if file_info[0] & win32con.FILE_ATTRIBUTE_REPARSE_POINT:
             raise OSError(
@@ -151,25 +237,57 @@ def _open_windows_capture_append(path: Path) -> int:
                 "capture path is a Windows reparse point",
                 path,
             )
-        try:
-            # Enforce the DACL while this is still the original CreateFile
-            # handle carrying WRITE_DAC. Transferring it into Python's CRT
-            # first can lose the authority SetSecurityInfo needs on Windows.
-            win32security.SetSecurityInfo(
-                handle,
-                win32security.SE_FILE_OBJECT,
-                win32security.DACL_SECURITY_INFORMATION
-                | win32security.PROTECTED_DACL_SECURITY_INFORMATION,
-                None,
-                None,
-                dacl,
-                None,
-            )
-        except Exception as exc:
-            raise OSError(
-                "Windows capture ACL could not be enforced "
-                f"({type(exc).__name__}: {exc})"
-            ) from exc
+        if not created_new:
+            try:
+                query_flags = (
+                    win32security.OWNER_SECURITY_INFORMATION
+                    | win32security.DACL_SECURITY_INFORMATION
+                )
+                descriptor = win32security.GetSecurityInfo(
+                    handle,
+                    win32security.SE_FILE_OBJECT,
+                    query_flags,
+                )
+                if not _windows_dacl_is_owner_only(
+                    descriptor,
+                    owner_sid,
+                    ntsecuritycon,
+                    win32security,
+                ):
+                    # Existing files ignore the creation security descriptor,
+                    # so repair an unsafe DACL while this is still the original
+                    # CreateFile handle carrying WRITE_DAC. Avoid rewriting an
+                    # already-protected DACL: Windows may correctly deny that
+                    # redundant mutation even though append access is allowed.
+                    win32security.SetSecurityInfo(
+                        handle,
+                        win32security.SE_FILE_OBJECT,
+                        win32security.DACL_SECURITY_INFORMATION
+                        | win32security.PROTECTED_DACL_SECURITY_INFORMATION,
+                        None,
+                        None,
+                        dacl,
+                        None,
+                    )
+                    descriptor = win32security.GetSecurityInfo(
+                        handle,
+                        win32security.SE_FILE_OBJECT,
+                        query_flags,
+                    )
+                    if not _windows_dacl_is_owner_only(
+                        descriptor,
+                        owner_sid,
+                        ntsecuritycon,
+                        win32security,
+                    ):
+                        raise OSError(
+                            "Windows capture ACL verification failed after repair"
+                        )
+            except Exception as exc:
+                raise OSError(
+                    "Windows capture ACL could not be enforced "
+                    f"({type(exc).__name__}: {exc})"
+                ) from exc
 
         # Transfer the native handle to Python's CRT descriptor exactly once.
         raw_handle = handle.Detach()

package/src/superlocalmemory/optimize/storage/db.py

@@ -212,8 +212,12 @@ class CacheDB:
             try:
                 import sqlite3 as _sq
                 test_conn = _sq.connect(str(self._db_path))
-                test_conn.execute("PRAGMA schema_version")
-                test_conn.close()
+                try:
+                    test_conn.execute("PRAGMA schema_version")
+                finally:
+                    # Windows will not rename an open SQLite file. Always
+                    # release the probe before corrupt-file recovery runs.
+                    test_conn.close()
             except Exception as exc:
                 corrupt_sidecar = self._db_path.with_suffix(
                     self._db_path.suffix + ".corrupt"

package/src/superlocalmemory/server/unified_daemon.py

@@ -1244,6 +1244,7 @@ async def lifespan(application: FastAPI):
     engine = None
     config = None
     canonical_remember_runtime = None
+    profile_runtime = None
 
     # The local dashboard obtains its short-lived browser credential from
     # ``/internal/token`` before its first write or token-gated read.  A
@@ -1916,11 +1917,17 @@ async def lifespan(application: FastAPI):
 
     except Exception:
         logger.exception("Engine init failed")  # auto-includes traceback
-        _release_canonical_remember_runtime(
+        writer_released = _release_canonical_remember_runtime(
             application, canonical_remember_runtime,
         )
         application.state.engine = None
         application.state.config = None
+        if engine is not None and writer_released:
+            try:
+                engine.close()
+            except Exception:
+                logger.debug("partially initialized engine cleanup failed", exc_info=True)
+        raise
 
     application.state.observe_buffer = _observe_buffer
 
@@ -4060,7 +4067,9 @@ def _run_materializer_operation(
                 "resident engine does not match pending profile"
             )
         from superlocalmemory.core.recall_gate import background_work
-        with background_work():
+        with background_work(
+            preempt_requested=lambda: bool(runtime is not None and runtime.transitioning),
+        ):
             return operation(engine)
 
 

package/src/superlocalmemory/storage/admission_codec.py

@@ -74,6 +74,16 @@ def _load_or_create_key(path: Path) -> bytes:
         )
     except FileExistsError:
         fd = -1
+    except OSError as exc:
+        try:
+            info = path.lstat()
+        except OSError:
+            raise AdmissionKeyError("admission key cannot be created") from exc
+        if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+            raise AdmissionKeyError(
+                "admission key path must be a regular file"
+            ) from exc
+        raise AdmissionKeyError("admission key cannot be created") from exc
     else:
         try:
             key = os.urandom(_KEY_BYTES)