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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvisx-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: MarvisX OSS — agent-native company-brain CLI runtime (init, status, brief, triage)
 Author: MarvisX maintainers
 License: BSL-1.1
@@ -68,6 +68,7 @@ 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"

{marvisx_cli-0.1.0 → marvisx_cli-0.2.0}/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.0}/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.0}/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.0}/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.0}/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.0}/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.0}/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.1.0 → marvisx_cli-0.2.0}/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,

marvisx_cli-0.2.0/core/cli/marvis_account.py

@@ -0,0 +1,132 @@
+# v1.0.0 - 2026-05-29 - open-core funnel: `marvis account status|link` (opt-in identity)
+"""``marvis account status|link`` — the opt-in account / install-claim surface.
+
+Registered onto the SAME Typer ``app`` as ``marvis init`` via ``register(app)``, like
+``marvis_telemetry`` / ``marvis_hooks`` / ``marvis_mcp``.
+
+- ``status`` is local-only (no network): shows whether an ``install_id`` and a cloud
+  api key exist (presence, not values), the configured endpoints, and the effective
+  telemetry state. Safe to paste into a bug report.
+- ``link`` is the explicit opt-in: it provisions the install with the cloud backend
+  (mints + stores an api key once) and prints the **claim code** + the dashboard URL.
+  The user signs in at the dashboard and pastes the code to attach this install to
+  their account (the web side calls ``/v1/installs/claim``). Telemetry being off does
+  NOT block ``link`` — it is a deliberate user action, distinct from passive telemetry.
+
+Heavy work is avoided: ``status`` only reads ``~/.marvis``; ``link`` does one short,
+fail-silent provisioning POST (≤2s) reusing the sender's contract.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from core.cli._runtime_ctx import console, emit as _emit_result
+
+ACCOUNT_URL = "https://justaskmarvis.com/account"
+_PANEL_ACCOUNT = "Account"
+
+
+def register(app: typer.Typer) -> None:
+    """Attach the ``account`` command group onto an existing app."""
+    app.add_typer(
+        account_app,
+        name="account",
+        rich_help_panel=_PANEL_ACCOUNT,
+        help="Link this install to a justaskmarvis.com account (opt-in) / inspect it.",
+    )
+
+
+account_app = typer.Typer(add_completion=False, no_args_is_help=True)
+
+
+def _claim_code() -> str | None:
+    from core.telemetry import client as _tc
+
+    try:
+        path = _tc._marvis_dir() / "telemetry_claim_code"
+        if path.is_file():
+            value = path.read_text(encoding="utf-8").strip()
+            return value or None
+    except Exception:  # noqa: BLE001
+        return None
+    return None
+
+
+def _status_result() -> dict[str, Any]:
+    """Local-only account snapshot (no network)."""
+    from core.telemetry import client as _tc
+    from core.telemetry import sender as _sender
+
+    return {
+        "telemetry_enabled": _tc._enabled(),
+        "install_id_present": (_tc._marvis_dir() / "telemetry_id").is_file(),
+        "account_provisioned": _sender._load_key() is not None,
+        "claim_code_present": _claim_code() is not None,
+        "ingest_endpoint": _sender._endpoint("ingest_endpoint", _sender.DEFAULT_INGEST_ENDPOINT),
+        "provision_endpoint": _sender._endpoint("provision_endpoint", _sender.DEFAULT_PROVISION_ENDPOINT),
+        "account_url": ACCOUNT_URL,
+    }
+
+
+def _link_result() -> dict[str, Any]:
+    """Provision the install (mint+store a key once) and return the claim code. One short POST."""
+    from core.telemetry import client as _tc
+    from core.telemetry import sender as _sender
+
+    key = _sender._ensure_key(_tc._install_id())
+    return {
+        "provisioned": key is not None,
+        "claim_code": _claim_code() if key is not None else None,
+        "account_url": ACCOUNT_URL,
+        "provision_endpoint": _sender._endpoint("provision_endpoint", _sender.DEFAULT_PROVISION_ENDPOINT),
+    }
+
+
+@account_app.command("status")
+def status_cmd(
+    json_out: bool = typer.Option(False, "--json", help="Emit pure JSON to stdout."),
+) -> None:
+    """Show the local account state (presence only, no values; no network)."""
+    result = _status_result()
+
+    def _render(r: dict[str, Any]) -> None:
+        from rich.table import Table
+
+        t = Table(title="marvis account status", show_header=False)
+        t.add_row("Telemetry", "[green]on[/]" if r["telemetry_enabled"] else "[yellow]off[/]")
+        t.add_row("install_id", "[green]present[/]" if r["install_id_present"] else "[dim]not yet created[/]")
+        t.add_row("Account", "[green]provisioned[/]" if r["account_provisioned"] else "[dim]not linked[/]")
+        t.add_row("Claim code", "[green]present[/]" if r["claim_code_present"] else "[dim]none[/]")
+        t.add_row("Ingest", r["ingest_endpoint"])
+        console.print(t)
+        if not r["account_provisioned"]:
+            console.print(f"[dim]Run [bold]marvis account link[/] to link this install at {r['account_url']}.[/]")
+
+    _emit_result(result, json_out=json_out, render=_render)
+
+
+@account_app.command("link")
+def link_cmd(
+    json_out: bool = typer.Option(False, "--json", help="Emit pure JSON to stdout."),
+) -> None:
+    """Provision this install and print the claim code to link it to your account."""
+    result = _link_result()
+
+    def _render(r: dict[str, Any]) -> None:
+        if not r["provisioned"]:
+            console.print(
+                f"[yellow]Could not reach {r['provision_endpoint']}.[/] "
+                "Check your connection and retry — nothing was changed."
+            )
+            return
+        code = r["claim_code"]
+        console.print("[green]Install provisioned.[/] To link it to your account:")
+        console.print(f"  1. Sign in at [bold]{r['account_url']}[/]")
+        if code:
+            console.print(f"  2. Paste this claim code: [bold]{code}[/]")
+        else:
+            console.print("  2. Use 'claim install' in the dashboard (claim code issued at first provision).")
+
+    _emit_result(result, json_out=json_out, render=_render)

{marvisx_cli-0.1.0 → marvisx_cli-0.2.0}/core/cli/marvis_init.py

@@ -60,7 +60,18 @@ from core.wizard.defaults import (
 )
 
 DEFAULT_SETTINGS_FILENAME = "settings.yaml"
-CLI_VERSION = "marvis-init 0.1.0"
+CLI_VERSION = "marvis-init 0.2.0"
+
+
+def _default_vault_dir() -> Path:
+    """Resolve the vault dir honoring ``$MARVIS_VAULT_DIR`` → ``~/.marvis``.
+
+    Mirrors ``core.telemetry.client._marvis_dir()`` so that, when ``--vault-dir``
+    is not passed, ``marvis init`` writes to the env-configured vault instead of
+    silently polluting the real ``~/.marvis``.
+    """
+    env_dir = os.environ.get("MARVIS_VAULT_DIR")
+    return Path(env_dir).expanduser() if env_dir else DEFAULT_VAULT_DIR
 BSL_NOTICE = (
     "MarvisX is distributed under the Business Source License 1.1. "
     "Personal, internal and non-commercial use is free; commercial hosting "
@@ -504,6 +515,12 @@ def _telemetry_root_hook(invoked_subcommand: str | None) -> None:
 
         _telemetry.maybe_first_run_notice()
         _telemetry.emit("cli_command", {"command": invoked_subcommand or "init"})
+
+        # Opportunistic daily aggregate rollup (provision + send), throttled 24h,
+        # detached + fail-silent — same opt-out gate as emit(). Never blocks the command.
+        from core.telemetry import sender as _sender
+
+        _sender.maybe_send_rollup()
     except Exception:  # noqa: BLE001 — telemetry must never affect the command
         pass
 
@@ -570,10 +587,10 @@ def init(
         "--dry-run",
         help="Mostra il piano senza scrivere file ne' vault.",
     ),
-    vault_dir: Path = typer.Option(
-        DEFAULT_VAULT_DIR,
+    vault_dir: Path | None = typer.Option(
+        None,
         "--vault-dir",
-        help="Cartella vault BYOK + settings.yaml (default ~/.marvis).",
+        help="Cartella vault BYOK + settings.yaml (default $MARVIS_VAULT_DIR o ~/.marvis).",
     ),
     settings_path: Path | None = typer.Option(
         None,
@@ -588,6 +605,10 @@ def init(
     ),
 ) -> None:
     """5-step interactive bootstrap riusando core.wizard shared lib."""
+    # When --vault-dir is omitted, honor $MARVIS_VAULT_DIR (else ~/.marvis) so
+    # init never silently writes to the real home vault under isolation.
+    if vault_dir is None:
+        vault_dir = _default_vault_dir()
     interactive = _is_interactive() and not no_interactive
 
     if config is not None:
@@ -733,6 +754,11 @@ from core.cli.marvis_telemetry import register as _register_telemetry  # noqa: E
 
 _register_telemetry(app)
 
+# `marvis account status/link` — opt-in identity: link this install to a web account.
+from core.cli.marvis_account import register as _register_account  # noqa: E402
+
+_register_account(app)
+
 # `marvis doctor` — install-health self-diagnostic with actionable remediation.
 from core.cli.marvis_doctor import register as _register_doctor  # noqa: E402
 

{marvisx_cli-0.1.0 → marvisx_cli-0.2.0}/core/cli/marvis_runtime.py

@@ -151,9 +151,18 @@ def status_cmd(
     settings_data = _settings_snapshot()
     llm = settings_data.get("llm") or {}
     byok = bool(_vault_state() or llm.get("provider"))
-    telemetry = bool(settings_data.get("telemetry", {}).get("enabled", False)) if isinstance(
-        settings_data.get("telemetry"), dict
-    ) else bool(settings_data.get("telemetry", False))
+    # Real EFFECTIVE state: reuse the same precedence `marvis telemetry status`
+    # uses (DO_NOT_TRACK / MARVIS_TELEMETRY env, then settings.yaml, default ON).
+    # The old inline check read only settings.yaml with a wrong default (off),
+    # so status showed "off" even when telemetry was actually ON.
+    try:
+        from core.telemetry.client import _enabled as _telemetry_enabled
+
+        telemetry = bool(_telemetry_enabled())
+    except Exception:  # noqa: BLE001 — status must never crash
+        telemetry = bool(settings_data.get("telemetry", {}).get("enabled", True)) if isinstance(
+            settings_data.get("telemetry"), dict
+        ) else bool(settings_data.get("telemetry", True))
 
     result = {
         "db_ok": db_ok,

{marvisx_cli-0.1.0 → marvisx_cli-0.2.0}/core/telemetry/client.py

@@ -220,7 +220,7 @@ def _install_id() -> str:
 
 def _marvis_version() -> str:
     """The CLI version (kept in lockstep with ``marvis version``)."""
-    return "0.1.0"
+    return "0.2.0"
 
 
 def _os_name() -> str: