marvisx-cli 0.1.0__tar.gz → 0.2.1__tar.gz

{marvisx_cli-0.1.0/marvisx_cli.egg-info → marvisx_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvisx-cli
-Version: 0.1.0
+Version: 0.2.1
 Summary: MarvisX OSS — agent-native company-brain CLI runtime (init, status, brief, triage)
 Author: MarvisX maintainers
 License: BSL-1.1
@@ -68,9 +68,12 @@ Requires-Dist: tokenizers>=0.20
 Requires-Dist: huggingface-hub>=0.24
 Requires-Dist: numpy>=1.26
 Requires-Dist: psutil>=5.9.0
+Requires-Dist: sqlite-vec>=0.1.6
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: pytest-cov>=5; extra == "dev"
+Provides-Extra: keyring
+Requires-Dist: keyring>=24; extra == "keyring"
 Dynamic: license-file
 
 # marvis init

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/config.py

@@ -8,6 +8,29 @@ from typing import Literal
 from pydantic import AliasChoices, Field, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+# Prod (Hetzner/Docker) ships the vec0 loadable at this path; it stays the
+# final fallback so prod keeps working unchanged.
+_VEC0_PATH_PROD_DEFAULT = "/data/pir/lib/vec0"
+
+
+def _default_vec0_path() -> str:
+    """Resolve the vec0 loadable path for sqlite-vec.
+
+    Order:
+      1. ``$VEC0_PATH`` env — handled by pydantic-settings (overrides this
+         default_factory when set), so it is NOT re-read here.
+      2. The installed ``sqlite_vec`` package's bundled loadable
+         (``sqlite_vec.loadable_path()``) — the OSS clean-install path
+         (`pip install sqlite-vec`), platform-correct (.so / .dylib).
+      3. ``/data/pir/lib/vec0`` — prod fallback.
+    """
+    try:
+        import sqlite_vec  # type: ignore
+
+        return str(sqlite_vec.loadable_path())
+    except Exception:  # noqa: BLE001 — missing/old package → prod fallback
+        return _VEC0_PATH_PROD_DEFAULT
+
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
@@ -381,8 +404,11 @@ class Settings(BaseSettings):
     # Voyage AI embeddings
     voyage_api_key: str = ""
 
-    # sqlite-vec
-    vec0_path: str = "/data/pir/lib/vec0"
+    # sqlite-vec: env VEC0_PATH → sqlite_vec.loadable_path() → prod fallback.
+    vec0_path: str = Field(
+        default_factory=_default_vec0_path,
+        validation_alias=AliasChoices("VEC0_PATH"),
+    )
 
     # LifeOS
     lifeos_data_dir: str = ""

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/db.py

@@ -101,6 +101,7 @@ _write_lock = asyncio.Lock()
 
 WRITER_LOCK_EVENT_LIMIT = 500
 WRITER_LOCK_SLOW_WAIT_MS = 50.0
+WRITER_LOCK_SLOW_HOLD_MS = 1000.0  # Fase 0: log writer holds >1s to separate offenders from queued victims
 _writer_metrics_lock = Lock()
 _writer_wait_events: deque[dict[str, Any]] = deque(maxlen=WRITER_LOCK_EVENT_LIMIT)
 _writer_hold_events: deque[dict[str, Any]] = deque(maxlen=WRITER_LOCK_EVENT_LIMIT)
@@ -291,7 +292,14 @@ def _start_writer_hold(
                 "blocked_by": blocked_by,
             }
         )
-        return holder
+    if wait_ms >= WRITER_LOCK_SLOW_WAIT_MS:
+        logger.warning(
+            "SQLite writer lock WAIT %.0fms for %s (blocked_by=%s)",
+            wait_ms,
+            label,
+            (blocked_by or {}).get("label"),
+        )
+    return holder
 
 
 def _finish_writer_hold(holder: dict[str, Any]) -> None:
@@ -312,6 +320,13 @@ def _finish_writer_hold(holder: dict[str, Any]) -> None:
                 "blocked_by": holder.get("blocked_by"),
             }
         )
+    if hold_ms >= WRITER_LOCK_SLOW_HOLD_MS:
+        logger.warning(
+            "SQLite writer lock HELD %.0fms by %s (waited %.0fms) — offender, not victim",
+            hold_ms,
+            holder["label"],
+            holder.get("wait_ms", 0.0),
+        )
 
 
 def get_writer_lock_snapshot(window_seconds: float = 60.0) -> dict[str, Any]:
@@ -494,18 +509,69 @@ async def wal_checkpoint() -> tuple[int, int, int]:
 # sqlite-vec support
 _vec_table_ready = False
 
+# Platform-specific loadable-extension suffixes. The vec0 loadable is `.so` on
+# Linux (prod), `.dylib` on macOS, `.dll` on Windows.
+_VEC0_SUFFIXES = (".so", ".dylib", ".dll")
+
+
+def resolve_vec0_loadable() -> tuple[str | None, bool]:
+    """Resolve the vec0 loadable path, cross-platform.
+
+    Returns ``(load_arg, found)`` where ``load_arg`` is the argument to pass to
+    ``SELECT load_extension(?)`` and ``found`` is True when a real loadable file
+    exists on disk.
+
+    Resolution (prod-safe by construction):
+      1. ``settings.vec0_path`` when it resolves to a real file: if it already
+         carries a known suffix use it as-is, otherwise probe ``.so`` /
+         ``.dylib`` / ``.dll``. Prod (Linux, ``/data/pir/lib/vec0`` →
+         ``vec0.so``, set via ``VEC0_PATH``) resolves here and keeps using the
+         exact configured path.
+      2. Else the installed ``sqlite_vec`` package's own loadable
+         (``sqlite_vec.loadable_path()``) — the OSS clean-install path, where
+         ``/data/pir/lib/vec0`` is absent and the bundled loadable is
+         platform-correct (.dylib on macOS, no longer rejected by a hardcoded
+         ``.so`` check).
+
+    The suffix-less ``load_arg`` lets SQLite append the platform suffix itself.
+    """
+    vec_path = Path(settings.vec0_path)
+    if vec_path.suffix:
+        if vec_path.exists():
+            return (str(vec_path), True)
+    else:
+        for suffix in _VEC0_SUFFIXES:
+            if vec_path.with_suffix(suffix).exists():
+                # Pass the suffix-less path; SQLite appends the platform suffix.
+                return (str(vec_path), True)
+
+    try:
+        import sqlite_vec  # type: ignore
+
+        pkg_path = Path(str(sqlite_vec.loadable_path()))
+        if pkg_path.exists():
+            return (str(pkg_path), True)
+        # loadable_path() returns a suffix-less base on some builds; probe.
+        for suffix in _VEC0_SUFFIXES:
+            if pkg_path.with_suffix(suffix).exists():
+                return (str(pkg_path), True)
+    except Exception:  # noqa: BLE001 — package missing/old → settings path is final
+        pass
+
+    # Nothing resolved; return the configured path so callers log a clear miss.
+    return (str(vec_path), False)
+
 
 async def ensure_vec_documents(db: aiosqlite.Connection) -> bool:
     """Load sqlite-vec on an existing connection and ensure vec_documents exists."""
     global _vec_table_ready
-    vec_path = Path(settings.vec0_path)
-    vec_so = vec_path.with_suffix(".so") if not vec_path.suffix else vec_path
-    if not vec_so.exists():
+    load_arg, found = resolve_vec0_loadable()
+    if not found or load_arg is None:
         return False
 
     if not getattr(db, "_pir_vec_extension_loaded", False):
         await db._execute(db._conn.enable_load_extension, True)
-        await db.execute("SELECT load_extension(?)", [str(vec_path)])
+        await db.execute("SELECT load_extension(?)", [load_arg])
         setattr(db, "_pir_vec_extension_loaded", True)
     if not _vec_table_ready:
         await db.execute("""

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/main.py

@@ -870,11 +870,17 @@ async def _notifications_acted_at_sync_loop() -> None:
             async with write_db() as db:
                 now = datetime.now(timezone.utc).isoformat()
                 await db.execute(
+                    # Drive off the small still-pending set + idx_notifications_pending_sync
+                    # (migration 144): NOT IN (pending) is sargable, the prior
+                    # `!= 'pending'` forced a full scan -> ~15s writer-lock hold.
+                    # A target_id pointing at a deleted task is now acted too (benign:
+                    # the task is no longer pending). tasks.id is PK so no NULL in the
+                    # subquery -> NOT IN is safe.
                     """UPDATE notifications
                        SET acted_at = ?, read_at = COALESCE(read_at, ?)
                        WHERE acted_at IS NULL AND type = 'task_pending'
-                       AND target_type = 'task' AND target_id IN (
-                           SELECT id FROM tasks WHERE status != 'pending'
+                       AND target_type = 'task' AND target_id NOT IN (
+                           SELECT id FROM tasks WHERE status = 'pending'
                        )""",
                     (now, now),
                 )

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/rbac.py

@@ -80,9 +80,15 @@ def require_scope(*required_scopes: str) -> Callable[..., Awaitable[UserInfo]]:
         if not user.username.startswith("agent:") and user.username not in agent_usernames:
             return user
 
-        # Agent with no scopes defined = unrestricted (backward compat with existing tokens)
+        # Agent with no scopes (empty/null) = NO permission for scope-gated ops.
+        # Empty MUST deny, not allow-all: an unscoped agent token previously
+        # passed every scope check (authz bypass — empty list satisfied
+        # `not user.scopes`). Scope-gated endpoints require an explicit grant.
         if not user.scopes:
-            return user
+            raise HTTPException(
+                status_code=403,
+                detail=f"Token missing required scopes: {list(required_scopes)}",
+            )
 
         # Check that all required scopes are present
         missing = [s for s in required_scopes if s not in user.scopes]

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/services/brain/findings.py

@@ -1299,7 +1299,12 @@ async def emit_finding_dedup(
             return (finding_id, False)
 
         # INSERT path
-        finding_id = f"fnd_{uuid.uuid4().hex[:24]}"
+        # Finding.finding_id requires exactly 32 chars (min_length=32,
+        # max_length=32), matching the BLAKE2b-16 hex sibling ids
+        # (signal_id/operation_id/event_id). Keep the "fnd_" prefix and pad to
+        # 32 total chars (4 prefix + 28 hex) so every findings endpoint
+        # validates instead of 500-ing.
+        finding_id = f"fnd_{uuid.uuid4().hex[:28]}"
         now_iso = _utc_iso(datetime.now(timezone.utc))
         if expires_at is None:
             expires_iso = _utc_iso(

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/services/embedding_service.py

@@ -482,9 +482,15 @@ async def embed_task_document(
 
 
 async def _ensure_vec_documents(db: aiosqlite.Connection, vec0_path: str) -> None:
-    vec_path = str(Path(vec0_path))
+    # Prefer the shared cross-platform resolver (sqlite_vec package loader /
+    # .so / .dylib probe) so macOS (.dylib) loads; fall back to the passed path.
+    from core.api.db import resolve_vec0_loadable
+
+    load_arg, found = resolve_vec0_loadable()
+    if not found or load_arg is None:
+        load_arg = str(Path(vec0_path))
     await db._execute(db._conn.enable_load_extension, True)
-    await db.execute("SELECT load_extension(?)", [vec_path])
+    await db.execute("SELECT load_extension(?)", [load_arg])
     await db.execute("""
         CREATE VIRTUAL TABLE IF NOT EXISTS vec_documents USING vec0(
             doc_id INTEGER PRIMARY KEY,

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/services/ingest/insert_saga.py

@@ -20,8 +20,57 @@ from core.api.services.ingest.events import broadcast_ingest_changed
 
 logger = logging.getLogger(__name__)
 
+# Prod default (Docker): /data/projects exists, so the resolved value stays
+# /data/projects there. Kept as a module-level attribute (not inlined) so it
+# remains an explicit override point — tests monkeypatch it, and a future
+# runtime hook could set it directly. _projects_root() treats any non-default
+# value here as authoritative.
 PROJECTS_ROOT = Path("/data/projects")
 REPO_ROOT = repo_root(__file__)
+
+
+def _projects_root() -> Path:
+    """Resolve the projects root the same way the rest of the runtime does.
+
+    Order (prod-safe by construction):
+      1. The module-level ``PROJECTS_ROOT`` when it has been overridden from its
+         ``/data/projects`` default (tests monkeypatch it; a runtime hook may
+         set it). An explicit override always wins.
+      2. ``$MARVIS_PROJECTS_ROOT`` (canonical override, see wizard/defaults.py).
+         Prod does NOT set it, so prod is unaffected.
+      3. The runtime-applied project dirs (``PROJECT_DIRS[0]``), which
+         ``runtime_settings.apply_marvis_settings`` populates from
+         ``~/.marvis/settings.yaml`` ``storage.projects_root`` — but ONLY when
+         ``/data/projects`` does NOT exist, so prod (where it does) keeps using
+         ``/data/projects`` rather than the DB-loaded ``~/workspace/projects``.
+      4. ``/data/projects`` default.
+
+    Resolved lazily per-call: the API process applies settings.yaml AFTER this
+    module imports, so reading at import time would lock in the bare default.
+    """
+    default_root = Path("/data/projects")
+
+    # 1. Explicit module-level override (tests / runtime hook).
+    if PROJECTS_ROOT != default_root:
+        return Path(PROJECTS_ROOT).expanduser().resolve()
+
+    # 2. Canonical env override (OSS non-Docker).
+    env_root = os.environ.get("MARVIS_PROJECTS_ROOT")
+    if env_root:
+        return Path(env_root).expanduser().resolve()
+
+    # 3. Runtime settings (settings.yaml → PROJECT_DIRS) on non-Docker installs.
+    if not default_root.exists():
+        try:
+            from core.api.routers.projects import PROJECT_DIRS
+
+            if PROJECT_DIRS:
+                return Path(PROJECT_DIRS[0]).expanduser().resolve()
+        except Exception:  # noqa: BLE001 — never let resolution crash the saga
+            pass
+
+    # 4. Prod Docker default.
+    return default_root.resolve()
 SUBPROCESS_TIMEOUT_SEC = 60
 
 # Phase 1.5 E6: keep-ref so fire-and-forget background tasks don't get GC'd
@@ -53,7 +102,7 @@ ProjectType = Literal["work", "code", "system"]
 
 
 def _project_root(slug: str) -> Path:
-    return (PROJECTS_ROOT / slug).resolve()
+    return (_projects_root() / slug).resolve()
 
 
 def _load_project_entry(slug: str) -> tuple[ProjectType, Path | None]:
@@ -418,12 +467,13 @@ async def _ensure_kg_edge(
         },
         ensure_ascii=False,
     )
+    projects_root = _projects_root()
     candidate_paths = [
         str(target_path),
-        str(target_path.relative_to(PROJECTS_ROOT)),
+        str(target_path.relative_to(projects_root)),
     ]
     if project_slug == "marvisx":
-        candidate_paths.append(f"projects/{target_path.relative_to(PROJECTS_ROOT)}")
+        candidate_paths.append(f"projects/{target_path.relative_to(projects_root)}")
 
     async with acquire_write_db() as db:
         await db.execute(

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/services/terminal_metrics_dump.py

@@ -32,6 +32,22 @@ INTERNET_PROBE_TARGETS = (
 )
 
 
+_PROBE_DISABLED_VALUES = {"0", "off", "false", "no"}
+
+
+def network_probe_enabled() -> bool:
+    """Whether the periodic internet probe (cloudflare.com/cdn-cgi/trace) runs.
+
+    Gated by ``$MARVIS_NETWORK_PROBE``: values in {0, off, false, no}
+    (case-insensitive) disable the probe — this is what makes an "offline mode"
+    honest. Default (env unset / any other value) = ON, so prod is unchanged.
+    """
+    raw = os.environ.get("MARVIS_NETWORK_PROBE")
+    if raw is None:
+        return True
+    return raw.strip().lower() not in _PROBE_DISABLED_VALUES
+
+
 def terminal_metrics_path(
     *,
     now: datetime | None = None,
@@ -175,17 +191,20 @@ async def terminal_metrics_background_loop(
         collector.record_event_loop_lag(max(0.0, (now - expected_wake) * 1000))
 
         if now >= next_probe_at:
-            try:
-                probe = await sample_internet_probe(collector)
-                await append_terminal_metrics_record(
-                    {
-                        "kind": "internet_probe",
-                        "probe": probe,
-                    },
-                    output_dir=output_dir,
-                )
-            except Exception:
-                logger.warning("terminal metrics internet probe failed", exc_info=True)
+            if network_probe_enabled():
+                try:
+                    probe = await sample_internet_probe(collector)
+                    await append_terminal_metrics_record(
+                        {
+                            "kind": "internet_probe",
+                            "probe": probe,
+                        },
+                        output_dir=output_dir,
+                    )
+                except Exception:
+                    logger.warning(
+                        "terminal metrics internet probe failed", exc_info=True
+                    )
             next_probe_at = now + network_interval_seconds
 
         if now >= next_dump_at:

marvisx_cli-0.2.1/core/api/tests/test_require_scope_empty_deny.py

@@ -0,0 +1,65 @@
+"""Regression: require_scope must DENY agent tokens with empty/null scopes.
+
+Audit S4: an agent token with scopes=[] previously satisfied `not user.scopes`
+and was treated as unrestricted (authz bypass — a scope-gated PATCH succeeded
+with an empty-scope token). Empty scopes must grant NO permission.
+"""
+from __future__ import annotations
+
+import pytest
+from fastapi import HTTPException
+
+from core.api.models.auth import UserInfo
+from core.api.rbac import require_scope
+
+
+def _agent(scopes: list[str]) -> UserInfo:
+    # "agent:" prefix forces the agent path (not the human cookie bypass).
+    return UserInfo(
+        username="agent:tester",
+        user_id="tok-1",
+        system_role="operator",
+        user_type="agent",
+        scopes=scopes,
+    )
+
+
+def _human(scopes: list[str]) -> UserInfo:
+    return UserInfo(
+        username="emilio",
+        user_id="user-1",
+        system_role="operator",
+        user_type="human",
+        scopes=scopes,
+    )
+
+
+@pytest.mark.asyncio
+async def test_empty_scopes_agent_denied():
+    check = require_scope("write")
+    with pytest.raises(HTTPException) as exc:
+        await check(user=_agent([]))
+    assert exc.value.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_matching_scope_agent_allowed():
+    check = require_scope("write")
+    user = await check(user=_agent(["read", "write"]))
+    assert user.username == "agent:tester"
+
+
+@pytest.mark.asyncio
+async def test_missing_scope_agent_denied():
+    check = require_scope("write")
+    with pytest.raises(HTTPException) as exc:
+        await check(user=_agent(["read"]))
+    assert exc.value.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_human_bypasses_scope_check_even_with_empty_scopes():
+    # Cookie/JWT humans are gated by role, not scopes — empty scopes is fine.
+    check = require_scope("write")
+    user = await check(user=_human([]))
+    assert user.username == "emilio"

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/tests/test_safety_bridge.py

@@ -345,3 +345,60 @@ def test_bash_action_returns_first_matching_rule(monkeypatch):
 
     assert decision.allowed is False
     assert decision.rule == "bash-merge"
+
+
+def test_secret_scan_runs_outside_git_repo(monkeypatch):
+    """S5a: secret scan must NOT fail open when cwd is not a git repo.
+
+    Previously resolve_repo_root() returning None silently allowed, so a
+    `git commit` of an API_KEY=sk-live-... outside a repo slipped through.
+    """
+    bridge = _load_bridge_module()
+    monkeypatch.setattr(
+        bridge, "resolve_repo_root", lambda file_path, cwd=None: None
+    )
+
+    decision = bridge.check_secret_scan(
+        "git commit -m 'add config' && export API_KEY=sk-live-abcd1234efgh5678ijkl",
+        "/tmp/not-a-repo",
+        _config(),
+    )
+
+    assert decision.allowed is False
+    assert decision.rule == "secret-scan"
+
+
+def test_secret_scan_outside_repo_allows_clean_command(monkeypatch):
+    """Outside a git repo, a clean commit command (no secret) is still allowed."""
+    bridge = _load_bridge_module()
+    monkeypatch.setattr(
+        bridge, "resolve_repo_root", lambda file_path, cwd=None: None
+    )
+
+    decision = bridge.check_secret_scan(
+        "git commit -m 'docs: tidy readme'",
+        "/tmp/not-a-repo",
+        _config(),
+    )
+
+    assert decision.allowed is True
+
+
+def test_secret_scan_blocks_secret_in_staged_diff(monkeypatch):
+    """In-repo path (unchanged behaviour): secret in staged diff is blocked."""
+    bridge = _load_bridge_module()
+    monkeypatch.setattr(
+        bridge, "resolve_repo_root", lambda file_path, cwd=None: "/repo"
+    )
+    monkeypatch.setattr(
+        bridge,
+        "_git_output",
+        lambda args, cwd: "+API_KEY=sk-live-abcd1234efgh5678ijkl",
+    )
+
+    decision = bridge.check_secret_scan(
+        "git commit -m 'add config'", "/repo", _config()
+    )
+
+    assert decision.allowed is False
+    assert decision.rule == "secret-scan"

{marvisx_cli-0.1.0 → marvisx_cli-0.2.1}/core/api/use_cases/search.py

@@ -225,20 +225,17 @@ async def trigger_reindex(
 
 async def _reindex_type(doc_type: str, workspace_id: str) -> dict:
     """Reindex a single document type. Returns stats dict."""
-    from pathlib import Path
-
-    from core.api.db import _configure_connection
+    from core.api.db import _configure_connection, resolve_vec0_loadable
 
     db = await aiosqlite.connect(settings.db_path)
     await _configure_connection(db)
     db.row_factory = aiosqlite.Row
     await db.execute("PRAGMA busy_timeout=60000")
 
-    vec_path = Path(settings.vec0_path)
-    vec_so = vec_path.with_suffix(".so") if not vec_path.suffix else vec_path
-    if vec_so.exists():
+    load_arg, vec_found = resolve_vec0_loadable()
+    if vec_found and load_arg is not None:
         await db._execute(db._conn.enable_load_extension, True)
-        await db.execute("SELECT load_extension(?)", [str(vec_path)])
+        await db.execute("SELECT load_extension(?)", [load_arg])
         await db.execute("""
             CREATE VIRTUAL TABLE IF NOT EXISTS vec_documents USING vec0(
                 doc_id INTEGER PRIMARY KEY,
@@ -272,8 +269,7 @@ async def _reindex_all_bg(db_path: str) -> None:
     Uses a SINGLE connection with vec extension loaded as both db and vec_db.
     Two separate writers to the same DB cause 'database is locked' errors.
     """
-    from pathlib import Path
-    from core.api.db import _configure_connection
+    from core.api.db import _configure_connection, resolve_vec0_loadable
 
     logger.info("Reindex all: starting background job")
     try:
@@ -282,12 +278,11 @@ async def _reindex_all_bg(db_path: str) -> None:
         db.row_factory = aiosqlite.Row
         # Higher busy_timeout for background reindex — avoids blocking regular requests
         await db.execute("PRAGMA busy_timeout=60000")
-        # Load vec extension on the same connection
-        vec_path = Path(settings.vec0_path)
-        vec_so = vec_path.with_suffix(".so") if not vec_path.suffix else vec_path
-        if vec_so.exists():
+        # Load vec extension on the same connection (cross-platform: .so/.dylib)
+        load_arg, vec_found = resolve_vec0_loadable()
+        if vec_found and load_arg is not None:
             await db._execute(db._conn.enable_load_extension, True)
-            await db.execute("SELECT load_extension(?)", [str(vec_path)])
+            await db.execute("SELECT load_extension(?)", [load_arg])
             await db.execute("""
                 CREATE VIRTUAL TABLE IF NOT EXISTS vec_documents USING vec0(
                     doc_id INTEGER PRIMARY KEY,