marvisx-cli 0.3.5__tar.gz → 0.3.7b1__tar.gz

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/LICENSE

@@ -5,19 +5,18 @@ Parameters
 Licensor:             Emilio Martucci
 Licensed Work:        MarvisX
                       The Licensed Work is (c) 2026 Emilio Martucci.
-Additional Use Grant: You may make production use of the Licensed Work only
-                      for personal, non-commercial purposes (for example,
-                      self-hosting it for your own individual use). Any other
-                      production use is not granted here and requires a separate
-                      commercial license from the Licensor. Uses that are NOT
-                      granted include, without limitation: any commercial use;
-                      any use by, within, or for the benefit of a business,
-                      company, or other organization; offering the Licensed
-                      Work (or a modified or adapted version of it) to third
-                      parties as a hosted or managed service; and using a
-                      modified or adapted version of the Licensed Work as, or
-                      as part of, a product or service that competes with the
-                      Licensor.
+Additional Use Grant: You may make production use of the Licensed Work,
+                      including for internal business and commercial
+                      purposes and including self-hosting the Licensed
+                      Work for your own use, provided that you may not
+                      provide the Licensed Work to third parties as a
+                      Hosted or Managed Service. A "Hosted or Managed
+                      Service" is a commercial offering that gives third
+                      parties (other than your employees and contractors)
+                      access to the substantial functionality of the
+                      Licensed Work, or of a modified or derived version
+                      of it, or that otherwise competes with a product or
+                      service the Licensor offers using the Licensed Work.
 Change Date:          2030-01-01
 Change License:       Apache License, Version 2.0
 

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/MANIFEST.in

@@ -10,4 +10,5 @@ recursive-include migrations *.sql
 recursive-include core/scripts/install_hooks *.sh *.json *.py
 recursive-include core/api/templates *.md *.j2
 recursive-include core/api/mcp/tools/workflow_playbooks *.md
+recursive-include core/cli/guides *.md
 recursive-include projects/_template *

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvisx-cli
-Version: 0.3.5
+Version: 0.3.7b1
 Summary: MarvisX OSS — agent-native company-brain CLI runtime (init, status, brief, triage)
 Author: MarvisX maintainers
 License: BSL-1.1
@@ -31,6 +31,7 @@ Requires-Dist: click>=8
 Requires-Dist: pydantic>=2.5
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: PyYAML>=6
+Requires-Dist: platformdirs>=4.0
 Requires-Dist: cryptography>=42
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: slowapi>=0.1.9

marvisx_cli-0.3.7b1/README.md

@@ -0,0 +1,124 @@
+# Marvis
+
+[![PyPI](https://img.shields.io/pypi/v/marvisx-cli.svg)](https://pypi.org/project/marvisx-cli/) [![License: BSL 1.1](https://img.shields.io/badge/license-BSL%201.1-blue.svg)](LICENSE) [![Change Date: Apache-2.0 2030](https://img.shields.io/badge/change%20date-Apache--2.0%20(2030)-lightgrey.svg)](LICENSE)
+
+**The Company Brain your agents install.** Use Claude Code, or whatever coding agent you run, to manage projects and coordinate your agents, not just write code. Marvis captures what your agents do as they work, structures it into a cross-project Knowledge Graph, and hands it back to them, so your work stays on track and the system learns from it. Self-hosted, EU-resident, with a tamper-evident audit log.
+
+**Open-core and free to run.** Marvis is the free core: you self-host it, read the source, fork it, audit it, at no cost. MarvisX is the commercial tier on top of the same brain: multi-department teams, data sovereignty and managed hosting, and autonomous, hands-off-the-keyboard operation. Marvis is what you install today; MarvisX is what you reach for when a single self-hosted instance is no longer enough.
+
+## Install
+
+Marvis runs as a CLI your agent drives. Install it, then let the agent you already use take it from there:
+
+```bash
+uv tool install marvisx-cli
+marvis init
+```
+
+`marvis init` scaffolds the project and installs the governance hooks, then exposes the MCP surface to your agent. Python 3.10–3.13; on 3.14, pin the interpreter: `uv tool install --python 3.13 marvisx-cli`. No `uv` yet? `curl -LsSf https://astral.sh/uv/install.sh | sh`.
+
+To run the full Console + API stack yourself, see [Self-hosting the full stack](#self-hosting-the-full-stack).
+
+## What it does, in plain terms
+
+- **Your agents stop forgetting.** Decisions, specs, playbooks, learnings and mistakes are captured as a side effect of the work your agents already do, not retyped by hand.
+- **Your work stays on track.** A reflective Brain layer compares what agents produce against your intent and surfaces drift early, before it compounds across sessions.
+- **One brain, many projects and teams.** A cross-project Knowledge Graph links decisions, code and documents, so an agent working in one project can see what was decided in another.
+- **Governed by default.** Constitution rules enforced at the hook level, plus a foreign-key-immutable audit log: every action traces back to the human who approved it.
+- **It lives in your terminal, not a dashboard.** An agent-native MCP surface keeps your existing Claude Code / Codex / Cursor as the place you work.
+
+## Under the hood
+
+- **Cross-project Knowledge Graph** with 17 deterministic edge types covering code, work-chain artifacts, knowledge-chain documents, cross-project references, and bridge edges. Canonical IDs follow `{prefix}:{kind}:{slug}`.
+- **Append-only audit log** (foreign-key + trigger enforced) with provenance pinned at the SQLite level. The managed **MarvisX** tier builds on it to cover the logging surface required by EU Regulation 2024/1689 (AI Act) Article 12.
+- **Brain reflection pipeline** in five layers — substrate, digest and journal, drift checker, memory operations, findings — closed by a Direction-Aware loop.
+- **Constitution-enforced safety rules** enforced by deterministic hook gates and an MCP mirror for providers without native hooks.
+- **Agent-native MCP surface** exposing 91 tools, callable identically from Claude Code, Codex, Gemini, OpenCode, and a web console.
+
+## Search and embedding quality
+
+Marvis defaults to **IBM Granite-Embedding-97m-Multilingual-R2** self-hosted via ONNX, blended with SQLite BM25 keyword search through Reciprocal Rank Fusion. Backend is selectable through `EMBEDDING_MODE`.
+
+This is a deliberate tradeoff: EU residency, self-hosting, and zero external embedding cost come at the cost of retrieval quality that is below commercial managed embedding providers. See [`docs/SEARCH-QUALITY.md`](docs/SEARCH-QUALITY.md) for the benchmark numbers, affected workflows, mitigations available today, and the Phase 2 fine-tune roadmap.
+
+## License posture
+
+- **Free to self-host and use internally**, including for commercial purposes. Code is **source-available** under the **Business Source License 1.1**; a paid license is required only to offer Marvis to third parties as a hosted or managed service. The change date automatically converts the code to **Apache License 2.0** four years after release.
+- Documentation and architectural patterns: **CC-BY 4.0**.
+
+This is open-core, not OSI open source: the core is free to run, read and fork, and the BSL holds back only competing commercial-as-a-service use until the change date. GitHub does not recognize the BSL and labels the repo `NOASSERTION`; the authoritative terms are in [`LICENSE`](LICENSE).
+
+## Architecture map
+
+The system groups capabilities into eight functional domains (`M1 Capture`, `M2 Index`, `M3 Retrieve`, `M4 Reflect`, `M5 Act`, `M6 Agent-native I/O`, `M7 Compliance`, `M8 Productization`). The Knowledge Graph stitches them together with canonical IDs and an audit chain.
+
+The full architectural description is the MarvisX preprint on Zenodo: [`10.5281/zenodo.20341860`](https://doi.org/10.5281/zenodo.20341860).
+
+## Repository layout
+
+```
+core/
+├── api/        # FastAPI service: KG, ingest, brain, MCP transport
+├── console/    # Next.js web console
+├── kb/         # Project-local knowledge base templates
+├── mcp-pir/    # MCP server (stdio) exposing the 91-tool surface
+└── scripts/    # Deployment, migration, and operational scripts
+
+deploy/
+└── _template/  # Reference deployment template
+                # (Docker Compose + environment scaffolding)
+```
+
+## Self-hosting the full stack
+
+The CLI above runs Marvis against a local SQLite database. To run the full Console + API stack yourself, use the reference Docker Compose deployment. Clone the repository, copy `deploy/_template/.env.example` to `.env`, populate the required secrets, and bring the stack up:
+
+```bash
+cp deploy/_template/.env.example deploy/_template/.env
+cd deploy/_template/
+docker compose up -d
+```
+
+The Console becomes available on the configured `CONSOLE_PORT` and the API on the configured `API_PORT`. Detailed first-run instructions are inside the deployment template.
+
+## MCP surface
+
+Marvis ships an MCP server exposing 91 tools across 11 categories: project and session context, tasks, handoffs, semantic search, learnings, costs, pull requests, knowledge graph queries, ingest triage, brain reflection layer, and audit-and-monitoring controls.
+
+The same surface is used by autonomous agents and by humans through the web console. The intent is parity: any action a user can take through the console, an agent can also take through MCP, and the reverse.
+
+## Single-user local runtime (`MARVIS_OSS_LOCAL`)
+
+The MCP server runs in-process: it calls the same use_cases the HTTP API calls, against the local SQLite database, with no uvicorn and no Node bridge. In this single-user mode there is no HTTP API in front of the database, so the HTTP audit chokepoint (which in the managed deployment forces every mutation through the API) does not exist.
+
+Audit is still recorded: the extracted use_cases write the audit log themselves (`core/api/use_cases/{tasks,pull_requests,audit}.py`), so a mutation issued through MCP still produces an audit row at the use_case level. What is lost is only the additional HTTP-surface chokepoint.
+
+Setting `MARVIS_OSS_LOCAL=1` (truthy: `1`/`true`/`yes`/`on`) makes the `block-db-direct-write` safety rule **advisory** — direct writes to a Marvis SQLite database are allowed with a warning instead of being blocked. When the variable is unset or falsey the rule is unchanged: direct DB writes are blocked fail-closed, exactly as in the managed deployment. This trade-off is intentional for single-user self-hosting and never weakens the default.
+
+**No-fork guarantee.** The HTTP API and the MCP server are not two implementations: both are thin adapters over the same `core/api/use_cases`, differing only in how they fill the per-call `CallerContext`. The proof is the API test suite staying green after the extraction — the same behaviour, exercised through the HTTP surface, over the identical use_cases the MCP server calls.
+
+## Telemetry
+
+Marvis sends anonymous, opt-out usage telemetry to help improve it: coarse event counts plus version and OS buckets, tied to a random install id (a plain UUID, never derived from your machine, user, or email). It never sends file content, project data, or personal information.
+
+Turn it off at any time:
+
+```bash
+marvis telemetry off
+```
+
+Or per environment: `MARVIS_TELEMETRY=0`, the universal `DO_NOT_TRACK=1`, or `telemetry: false` in `~/.marvis/settings.yaml`. With `MARVIS_TELEMETRY=log`, Marvis prints exactly what it would send to stderr and transmits nothing.
+
+## Documentation
+
+- [`docs/SEARCH-QUALITY.md`](docs/SEARCH-QUALITY.md) — search quality expectations, affected workflows, and mitigations
+
+## Contributing
+
+Issues and bug reports are welcome through the repository tracker.
+
+## References
+
+- Preprint (Zenodo): [`10.5281/zenodo.20341860`](https://doi.org/10.5281/zenodo.20341860)
+- License (code): Business Source License 1.1, change date converts to Apache License 2.0 four years after release
+- License (documentation): CC-BY 4.0

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/api/config.py

@@ -8,6 +8,8 @@ from typing import Literal
 from pydantic import AliasChoices, Field, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from core.platform import current_user, db_default_path
+
 # 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"
@@ -70,9 +72,22 @@ class Settings(BaseSettings):
         ),
     )
     db_path: str = Field(
-        default="console.db",
+        # Fallback when no MARVIS_DB_PATH/PIR_DB_PATH/DB_PATH env is set: the
+        # platformdirs data root (was a CWD-relative "console.db" that opened a
+        # different DB per launch directory — split-brain, and on Windows a
+        # nonsense root). The env aliases still win via pydantic; this factory
+        # runs ONLY when none are set.
+        default_factory=lambda: str(db_default_path()),
         validation_alias=AliasChoices("MARVIS_DB_PATH", "PIR_DB_PATH", "DB_PATH"),
     )
+    db_backup_dir: str = Field(
+        # Where pre-migration / pre-rebuild console.db snapshots land. Empty (the
+        # OSS default) keeps them next to the DB. In a managed deployment set this
+        # to a roomy data volume: the snapshots are full DB copies (>1GB) and a
+        # couple of them fill a small root disk — the recurring 90%-full cause.
+        default="",
+        validation_alias=AliasChoices("MARVIS_DB_BACKUP_DIR", "PIR_DB_BACKUP_DIR"),
+    )
     cookie_domain: str | None = Field(default=None, alias="COOKIE_DOMAIN")
     cors_origins_prod: list[str] = Field(
         default_factory=list,
@@ -544,16 +559,14 @@ class Settings(BaseSettings):
 
         Returns '' when GIT_RUNAS_USER is unset or already matches the current
         OS user (no privilege hop needed)."""
-        import pwd
-
         user = (self.git_runas_user or "").strip()
         if not user:
             return ""
-        try:
-            if pwd.getpwuid(os.getuid()).pw_name == user:
-                return ""
-        except (KeyError, OSError):
-            pass
+        # current_user() is pwd.getpwuid(os.getuid()).pw_name on POSIX (identical
+        # to the previous inline lookup) and getpass-based on Windows; the bare
+        # `import pwd` here crashed `marvis project list` on Windows.
+        if current_user() == user:
+            return ""
         return user
 
 

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/api/db.py

@@ -617,20 +617,24 @@ def run_migrations() -> None:
             and int(f.stem.split("_")[0]) > current_version
         ]
 
-        # Pre-migration backup (enterprise rollback strategy)
-        # Keep only last 2 backups to prevent disk fill (was unbounded)
+        # Pre-migration backup (enterprise rollback strategy).
+        # Snapshots go to settings.db_backup_dir (a roomy data volume in prod)
+        # when set, otherwise next to the DB. Rotation is GLOBAL keep-2 across
+        # ALL tags in that dir (migration `backup-v*`, kg `backup-pre-rebuild-*`,
+        # etc.) — full DB copies are >1GB, so only the two newest are retained.
         if pending:
-            backup_path = f"{settings.db_path}.backup-v{current_version}"
+            db_name = os.path.basename(settings.db_path)
+            backup_dir = settings.db_backup_dir or os.path.dirname(settings.db_path) or "."
+            backup_path = os.path.join(backup_dir, f"{db_name}.backup-v{current_version}")
             try:
+                os.makedirs(backup_dir, exist_ok=True)
                 shutil.copy2(settings.db_path, backup_path)
                 logger.info("Pre-migration backup: %s", backup_path)
-                # Rotate: keep only the 2 most recent backups
+                # Rotate: keep only the 2 most recent backups (global, all tags)
                 import glob
 
-                db_dir = os.path.dirname(settings.db_path) or "."
-                db_name = os.path.basename(settings.db_path)
                 backups = sorted(
-                    glob.glob(os.path.join(db_dir, f"{db_name}.backup-v*")),
+                    glob.glob(os.path.join(backup_dir, f"{db_name}.backup-*")),
                     key=os.path.getmtime,
                 )
                 for old_backup in backups[:-2]:

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/api/mcp/tools/learnings.py

@@ -109,6 +109,59 @@ def register(mcp) -> None:
         except ServiceError as e:
             raise_mcp_error(e)
 
+    @mcp.tool()
+    async def update_learning(
+        learning_id: Annotated[str, Field(min_length=1)],
+        title: Annotated[str, Field(min_length=1, max_length=200)] | None = None,
+        category: LearningCategory | None = None,
+        description: Annotated[str, Field(min_length=1)] | None = None,
+        prevention: Annotated[str, Field(min_length=1)] | None = None,
+        severity: LearningSeverity | None = None,
+        module: str | None = None,
+        tags: list[str] | None = None,
+        project: str | None = None,
+    ) -> dict[str, Any]:
+        """Update an existing learning (operator+), then re-embed it so search/check_learnings see the new content immediately.
+
+        QUANDO USARLO: il contenuto di un learning e' obsoleto/incompleto (prevention piu' precisa, severity ricalibrata, nuovo modulo) ma vuoi PRESERVARE la history. BOUNDARY: update_learning aggiorna in-place + re-embed; delete_learning cancella permanente; create_learning scrive nuovo.
+        QUANDO NON USARLO: NOT per un learning nuovo -> usa create_learning. NOT per azzerare un campo a null: la superficie MCP NON puo' settare null (omettere un campo lo lascia invariato) -> usa l'HTTP PATCH se devi pulire un campo.
+        RESTITUISCE: il learning aggiornato {id, title, category, severity, prevention, tags, module, project, updated_at} — gia' ri-embeddato (retrievable by meaning, non solo keyword)."""
+        fields = {
+            k: v
+            for k, v in {
+                "title": title,
+                "category": category,
+                "description": description,
+                "prevention": prevention,
+                "severity": severity,
+                "module": module,
+                "tags": tags,
+                "project": project,
+            }.items()
+            if v is not None
+        }
+        try:
+            async with acquire_write_db(label="mcp.update_learning") as db:
+                result = await learnings_uc.update_learning(
+                    LOCAL_CTX, db, learning_id=learning_id, fields=fields
+                )
+            # Writer lock released: re-embed-on-write (mirror create_learning) so the
+            # updated content is retrievable by meaning immediately, not stale until
+            # a manual reindex.
+            await mcp_embed_learning(
+                learning_id=result.id,
+                title=result.title,
+                description=result.description,
+                category=result.category,
+                severity=result.severity,
+                prevention=result.prevention,
+                project=result.project,
+                workspace_id=LOCAL_CTX.workspace_id,
+            )
+            return dump(result)
+        except ServiceError as e:
+            raise_mcp_error(e)
+
     @mcp.tool()
     async def list_learnings(
         project: str | None = None,

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/api/models/tasks.py

@@ -18,7 +18,6 @@ VALID_STATUSES = {
 VALID_PRIORITIES = {"high", "medium", "low"}
 VALID_KINDS = {"normal", "idea"}
 VALID_SOURCES = {
-    "reflectx_proposal",
     "telegram",
     "manual",
     "session",
@@ -51,7 +50,7 @@ class TaskCreateRequest(BaseModel):
     priority: str = Field("medium", pattern=r"^(high|medium|low)$")
     source: str = Field(
         ...,
-        pattern=r"^(reflectx_proposal|telegram|manual|session|console|rem_proposal)$",
+        pattern=r"^(telegram|manual|session|console|rem_proposal)$",
     )
     source_ref: str | None = Field(None, max_length=500)
     owner_id: str | None = Field(

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/api/services/brain/jobs.py

@@ -283,7 +283,20 @@ async def _execute_cycle(
     event_count = 0
     journal_count = 0
 
-    collectors = collectors if collectors is not None else registered_collectors()
+    if collectors is None:
+        collectors = registered_collectors()
+        if not collectors:
+            # Standalone runtime (`marvis brain run` / brain_cycles_recompute via
+            # the CLI + stdio MCP) never runs the API lifespan startup hook that
+            # registers the source collectors, so the registry is empty and the
+            # cycle would silently collect 0 events even with in-window data
+            # (issue #6). Register them lazily here so the standalone path lights
+            # up the same capture→reflect collectors as the API service. Idempotent
+            # and inert when the API already registered them at startup.
+            from core.api.services.brain.sources import register_all_collectors
+
+            register_all_collectors()
+            collectors = registered_collectors()
 
     # Cycle window resolution (bug fix 2026-05-18). When caller did not pass
     # explicit window bounds (legacy periodic path), default to the legacy

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/cli/_brain_opportunistic.py

@@ -29,6 +29,7 @@ import shutil
 import sys
 from typing import Any
 
+from core.platform import secure_path
 from core.telemetry import client as _tc  # canonical ~/.marvis + settings.yaml reader
 
 _RUN_INTERVAL_S = 24 * 3600
@@ -71,10 +72,7 @@ def _mark_ran(now: float) -> None:
         path = _last_run_path()
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text(f"{now:.0f}\n", encoding="utf-8")
-        try:
-            os.chmod(path, 0o600)
-        except OSError:
-            pass
+        secure_path(path, mode=0o600)
     except Exception:  # noqa: BLE001
         pass
 

{marvisx_cli-0.3.5 → marvisx_cli-0.3.7b1}/core/cli/_brain_schedule.py

@@ -35,10 +35,13 @@ import sys
 from pathlib import Path
 from typing import Any
 
+from core.platform import current_uid
+
 # launchd Label / systemd unit base / cron marker — one identity across backends.
 _LABEL = "com.marvisx.brain"
 _UNIT = "marvis-brain"
 _CRON_MARKER = "# marvis-brain"
+_SCHTASKS_TN = "MarvisX Brain"  # Windows Task Scheduler task name
 
 # Default daily fire time (local), off-peak.
 _HOUR = 3
@@ -75,11 +78,11 @@ def _run(cmd: list[str], *, input_text: str | None = None) -> tuple[int, str, st
 
 
 def detect_backend() -> str:
-    """Return ``launchd`` | ``systemd`` | ``cron`` | ``unsupported``."""
+    """Return ``launchd`` | ``systemd`` | ``cron`` | ``schtasks`` | ``unsupported``."""
     if sys.platform == "darwin":
         return "launchd"
     if sys.platform.startswith("win"):
-        return "unsupported"
+        return "schtasks"
     if shutil.which("systemctl"):
         return "systemd"
     if shutil.which("crontab"):
@@ -93,7 +96,7 @@ def _marvis_path() -> str | None:
     if exe:
         return exe
     argv0 = sys.argv[0] if sys.argv else ""
-    if argv0.endswith(("marvis", "marvis-init")) and os.path.isfile(argv0):
+    if argv0.endswith(("marvis", "marvis.exe", "marvis-init", "marvis-init.exe")) and os.path.isfile(argv0):
         return os.path.abspath(argv0)
     return None
 
@@ -189,7 +192,7 @@ def _launchd_enable() -> dict[str, Any]:
     plist = _launchd_plist_path()
     plist.parent.mkdir(parents=True, exist_ok=True)
     plist.write_text(plist_text(marvis), encoding="utf-8")
-    domain = f"gui/{os.getuid()}"
+    domain = f"gui/{current_uid()}"
     # Idempotent: bootout an existing instance first (ignore failure), then bootstrap.
     _run(["launchctl", "bootout", f"{domain}/{_LABEL}"])
     rc, _out, err = _run(["launchctl", "bootstrap", domain, str(plist)])
@@ -203,7 +206,7 @@ def _launchd_enable() -> dict[str, Any]:
 
 def _launchd_disable() -> dict[str, Any]:
     plist = _launchd_plist_path()
-    rc, _out, err = _run(["launchctl", "bootout", f"gui/{os.getuid()}/{_LABEL}"])
+    rc, _out, err = _run(["launchctl", "bootout", f"gui/{current_uid()}/{_LABEL}"])
     removed = False
     if plist.is_file():
         plist.unlink()
@@ -214,7 +217,7 @@ def _launchd_disable() -> dict[str, Any]:
 
 def _launchd_status() -> dict[str, Any]:
     plist = _launchd_plist_path()
-    rc, _out, _err = _run(["launchctl", "print", f"gui/{os.getuid()}/{_LABEL}"])
+    rc, _out, _err = _run(["launchctl", "print", f"gui/{current_uid()}/{_LABEL}"])
     return {
         "backend": "launchd",
         "enabled": rc == 0,
@@ -335,13 +338,68 @@ def _cron_status() -> dict[str, Any]:
     return {"backend": "cron", "enabled": present}
 
 
+# ---------------------------------------------------------------------------
+# schtasks backend (Windows Task Scheduler)
+# ---------------------------------------------------------------------------
+
+
+def schtasks_argv_create(
+    marvis_path: str, *, hour: int = _HOUR, minute: int = _MINUTE, tn: str = _SCHTASKS_TN
+) -> list[str]:
+    """Build the ``schtasks /create`` argv (PURE — unit-tested).
+
+    ``/tr`` is ONE argv element; the program path keeps its OWN inner quotes so a
+    space in ``%USERPROFILE%`` (e.g. ``C:\\Users\\Marsida Curaj\\...``) survives Task
+    Scheduler parsing. ``_run`` passes a list (no shell), so subprocess does the
+    OUTER quoting via ``list2cmdline``; this builder owns only the inner ``/tr``.
+    ``/f`` force-overwrites = idempotent; no ``/ru`` = current user, no admin.
+    """
+    tr = f'"{marvis_path}" brain run --mode full'
+    return [
+        "schtasks", "/create", "/tn", tn, "/tr", tr,
+        "/sc", "DAILY", "/st", f"{hour:02d}:{minute:02d}", "/f",
+    ]
+
+
+def _schtasks_enable() -> dict[str, Any]:
+    marvis = _marvis_path()
+    if not marvis:
+        return {"backend": "schtasks", "ok": False, "error": "marvis not found on PATH"}
+    rc, _out, err = _run(schtasks_argv_create(marvis))
+    # schtasks can refuse on a password-protected / Microsoft-account user without
+    # stored creds; never crash — the opportunistic on-invocation upkeep is the net.
+    return {
+        "backend": "schtasks",
+        "ok": rc == 0,
+        "task_name": _SCHTASKS_TN,
+        "error": err.strip() if rc != 0 else None,
+        "warning": (
+            None
+            if rc == 0
+            else "could not register the Windows scheduled task; the opportunistic "
+            "on-invocation upkeep still runs whenever you use marvis"
+        ),
+    }
+
+
+def _schtasks_disable() -> dict[str, Any]:
+    # rc!=0 when the task does not exist — still a successful disable.
+    rc, _out, _err = _run(["schtasks", "/delete", "/tn", _SCHTASKS_TN, "/f"])
+    return {"backend": "schtasks", "ok": True, "deleted_rc": rc}
+
+
+def _schtasks_status() -> dict[str, Any]:
+    rc, _out, _err = _run(["schtasks", "/query", "/tn", _SCHTASKS_TN])
+    return {"backend": "schtasks", "enabled": rc == 0}
+
+
 # ---------------------------------------------------------------------------
 # Public dispatch
 # ---------------------------------------------------------------------------
 
-_ENABLE = {"launchd": _launchd_enable, "systemd": _systemd_enable, "cron": _cron_enable}
-_DISABLE = {"launchd": _launchd_disable, "systemd": _systemd_disable, "cron": _cron_disable}
-_STATUS = {"launchd": _launchd_status, "systemd": _systemd_status, "cron": _cron_status}
+_ENABLE = {"launchd": _launchd_enable, "systemd": _systemd_enable, "cron": _cron_enable, "schtasks": _schtasks_enable}
+_DISABLE = {"launchd": _launchd_disable, "systemd": _systemd_disable, "cron": _cron_disable, "schtasks": _schtasks_disable}
+_STATUS = {"launchd": _launchd_status, "systemd": _systemd_status, "cron": _cron_status, "schtasks": _schtasks_status}
 
 
 def enable(cadence: str = "daily") -> dict[str, Any]: