memgit 0.9.1__tar.gz → 0.10.0__tar.gz

{memgit-0.9.1 → memgit-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgit
-Version: 0.9.1
+Version: 0.10.0
 Summary: Git for AI memory — version-controlled context persistence across Claude, GPT, Gemini, Cursor, Windsurf, and more
 License: MIT
 Project-URL: Homepage, https://memgit.dev
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
 Requires-Dist: rich>=13.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp<2,>=1.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-anyio>=0.0.0; extra == "dev"
@@ -298,6 +298,33 @@ Since 0.8.0 it also **starts itself**: a project's first guide is created automa
 
 ---
 
+## memgit Pro — one memory across every machine
+
+The local engine, the store, the MCP server and every command below are MIT and never
+gated. **Pro** is the hosted layer for people who work on more than one machine or with a
+team: end-to-end-encrypted sync where the server stores ciphertext only, unlocked by one
+licence key.
+
+```bash
+memgit pro activate <key>     # validate the key with Polar and store it (mode 0600)
+memgit pro status             # Free / Pro, last verification, expiry
+memgit pro deactivate         # remove the key from this machine
+```
+
+- Buy a key at [memgit.dev/#pricing](https://memgit.dev/#pricing) — $12/month or $99/year,
+  billed by Polar (merchant of record, taxes handled). The key arrives by email and in your
+  Polar purchases page.
+- The only bytes that leave your machine are the key and memgit's public organisation id,
+  sent to Polar's validation endpoint. **No memory content is ever sent.**
+- Headless hosts: set `MEMGIT_LICENSE_KEY=<key>` in the MCP server's environment; it is
+  validated with the same cache and never written to disk.
+- Fail-open: a key that verified in the last 14 days keeps working offline; a rejected key
+  drops to Free with a clear message. A lapsed plan never locks your data — reads, pulls and
+  exports keep working.
+- If this store is logged in to memgit cloud, `pro activate` also upgrades that account.
+
+---
+
 ## Backups that actually happen
 
 memgit's premise is that the AI is the operator — but backup used to require a human to remember `memgit git init --remote <url>` and keep pushing. On this project's own store that meant 1,734 memories on one disk with no copy anywhere, five weeks in. A maintenance task that needs a human command is a task that will not happen.
@@ -414,6 +441,10 @@ memgit setup gemini-cli
 memgit setup hooks                # Claude Code hooks: resume at start, per-prompt recall,
                                   # capture guard + auto-sync at stop (--no-recall / --no-guard)
 
+# Pro (licence key)
+memgit pro activate <key>         # Polar-issued key; unlocks hosted E2E sync
+memgit pro status / deactivate
+
 # Server
 memgit serve                      # MCP stdio (Claude Code, Cursor, Windsurf, Cline)
 memgit serve --http               # HTTP REST (ChatGPT Custom Actions, Gemini)

{memgit-0.9.1 → memgit-0.10.0}/README.md

@@ -264,6 +264,33 @@ Since 0.8.0 it also **starts itself**: a project's first guide is created automa
 
 ---
 
+## memgit Pro — one memory across every machine
+
+The local engine, the store, the MCP server and every command below are MIT and never
+gated. **Pro** is the hosted layer for people who work on more than one machine or with a
+team: end-to-end-encrypted sync where the server stores ciphertext only, unlocked by one
+licence key.
+
+```bash
+memgit pro activate <key>     # validate the key with Polar and store it (mode 0600)
+memgit pro status             # Free / Pro, last verification, expiry
+memgit pro deactivate         # remove the key from this machine
+```
+
+- Buy a key at [memgit.dev/#pricing](https://memgit.dev/#pricing) — $12/month or $99/year,
+  billed by Polar (merchant of record, taxes handled). The key arrives by email and in your
+  Polar purchases page.
+- The only bytes that leave your machine are the key and memgit's public organisation id,
+  sent to Polar's validation endpoint. **No memory content is ever sent.**
+- Headless hosts: set `MEMGIT_LICENSE_KEY=<key>` in the MCP server's environment; it is
+  validated with the same cache and never written to disk.
+- Fail-open: a key that verified in the last 14 days keeps working offline; a rejected key
+  drops to Free with a clear message. A lapsed plan never locks your data — reads, pulls and
+  exports keep working.
+- If this store is logged in to memgit cloud, `pro activate` also upgrades that account.
+
+---
+
 ## Backups that actually happen
 
 memgit's premise is that the AI is the operator — but backup used to require a human to remember `memgit git init --remote <url>` and keep pushing. On this project's own store that meant 1,734 memories on one disk with no copy anywhere, five weeks in. A maintenance task that needs a human command is a task that will not happen.
@@ -380,6 +407,10 @@ memgit setup gemini-cli
 memgit setup hooks                # Claude Code hooks: resume at start, per-prompt recall,
                                   # capture guard + auto-sync at stop (--no-recall / --no-guard)
 
+# Pro (licence key)
+memgit pro activate <key>         # Polar-issued key; unlocks hosted E2E sync
+memgit pro status / deactivate
+
 # Server
 memgit serve                      # MCP stdio (Claude Code, Cursor, Windsurf, Cline)
 memgit serve --http               # HTTP REST (ChatGPT Custom Actions, Gemini)

{memgit-0.9.1 → memgit-0.10.0}/memgit/__init__.py

@@ -1,3 +1,3 @@
 """memgit — git for AI memory."""
 
-__version__ = "0.9.1"
+__version__ = "0.10.0"

{memgit-0.9.1 → memgit-0.10.0}/memgit/cli.py

@@ -1978,6 +1978,105 @@ def metrics(fmt_json, reset):
     console.print()
 
 
+@cli.command()
+@click.option('--json', 'fmt_json', is_flag=True, help='Machine-readable output')
+@click.option('--match', default=None, type=float,
+              help='Share of a memory\'s terms a file must carry to count as '
+                   'containing the fact (default 0.5)')
+@click.option('--reads', default=None, type=int,
+              help='How many files the counterfactual reader opens (default 3)')
+@click.option('--all-projects', is_flag=True,
+              help='Every project, not just the one you are standing in')
+@click.option('--root', type=click.Path(exists=True, file_okay=False),
+              help='Directory the counterfactual reader would search (default: cwd)')
+def savings(fmt_json, match, reads, all_projects, root):
+    """What memory cost, against what finding the same fact would have cost.
+
+    The counterfactual is stated, not implied: without memgit an agent needing
+    a fact would grep this project and read the best-matching files. That path
+    is mechanical, so it can be measured. Memories no file contains are counted
+    separately and NEVER priced — without memgit those facts are not found at
+    any number of tokens, and turning that into a savings figure would be the
+    fabrication `memgit metrics` was right to refuse.
+
+    The estimate is conservative on purpose: it counts the files only, not the
+    grep output, not the turns spent choosing what to open, and not the reads
+    that miss.
+    """
+    from . import savings as sv
+    from .project import detect_project
+    repo = _require_repo()
+    search_root = Path(root) if root else Path.cwd()
+    label = None if all_projects else detect_project(search_root)
+    r = sv.measure(repo, search_root, project=label,
+                   match=match if match is not None else sv.DEFAULT_MATCH,
+                   reads=reads if reads is not None else sv.DEFAULT_READS)
+
+    if fmt_json:
+        import json as _j
+        print(_j.dumps(r, indent=2))
+        return
+
+    from rich.rule import Rule
+    from rich import box
+
+    console.print()
+    console.print(Rule('[bold cyan]memgit savings[/bold cyan]  '
+                       '[dim]measured against a stated counterfactual[/dim]'))
+    console.print()
+    console.print(f'[dim]Project:[/dim] {r["project"] or "all"}   '
+                  f'[dim]Files a reader could open:[/dim] {r["files_indexed"]:,}   '
+                  f'[dim]Reads assumed:[/dim] {r["parameters"]["reads"]}   '
+                  f'[dim]Match:[/dim] {r["parameters"]["match"]:.0%}')
+    console.print()
+
+    if r['memories_considered'] == 0:
+        console.print('[dim]No recalled memories for this project yet — nothing '
+                      'to compare. The usage ledger fills as memories get '
+                      'surfaced.[/dim]')
+        console.print()
+        return
+
+    t = Table(box=box.SIMPLE, header_style='bold')
+    t.add_column('', min_width=34)
+    t.add_column('Tokens', justify='right')
+    t.add_row('With memgit (what was injected)', f'{r["memgit_tokens"]:,}')
+    t.add_row('Without memgit (files that would be read)',
+              f'{r["without_memgit_tokens"]:,}')
+    t.add_row('[bold]Saved[/bold]', f'[bold]{r["saved_tokens"]:,}[/bold]')
+    console.print(t)
+    if r['ratio']:
+        console.print(f'  Reading costs [bold]{r["ratio"]:.0f}x[/bold] what recall '
+                      f'costs, over {r["recalls_counted"]:,} recorded recalls of '
+                      f'{r["recoverable_from_files"]:,} memories.')
+    console.print()
+
+    if r['unrecoverable_from_files']:
+        console.print(
+            f'[bold yellow]{r["unrecoverable_from_files"]:,} of '
+            f'{r["memories_considered"]:,} recalled memories are in NO file in '
+            f'this project.[/bold yellow]')
+        console.print('  [dim]Not priced, deliberately. Without memgit these are '
+                      'not found more expensively, they are not found. That is '
+                      'the claim worth making, and it is a count, not a token '
+                      'figure.[/dim]')
+        console.print()
+
+    if r['top_savers']:
+        t2 = Table(box=box.SIMPLE, header_style='bold',
+                   title='Where the saving comes from', title_justify='left')
+        t2.add_column('Memory', min_width=30)
+        t2.add_column('Recalls', justify='right')
+        t2.add_column('Recall tok', justify='right')
+        t2.add_column('Read tok', justify='right')
+        for row in r['top_savers'][:8]:
+            t2.add_row(row['slug'][:48], f'{row["hits"]:,}',
+                       f'{row["memgit_tokens_per_recall"]:,}',
+                       f'{row["without_tokens_per_recall"]:,}')
+        console.print(t2)
+        console.print()
+
+
 @cli.group(invoke_without_command=True)
 @click.pass_context
 def backup(ctx):
@@ -3354,6 +3453,126 @@ if __name__ == '__main__':
     cli()
 
 
+# ── pro (licence-key entitlement via Polar; no extra, no telemetry) ──────────
+
+@cli.group(invoke_without_command=True)
+@click.pass_context
+def pro(ctx):
+    """memgit Pro — activate, inspect or remove a licence key.
+
+    Pro unlocks the hosted sync layer (memgit cloud) and future paid features.
+    The free CLI, store and MCP server are MIT and never gated. The only bytes
+    that leave this machine are the key and memgit's public organisation id,
+    sent to Polar's validation endpoint; no memory content is ever sent.
+    """
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(pro_status)
+
+
+@pro.command('activate')
+@click.argument('key')
+@click.option('--no-cloud', is_flag=True, help='Do not also attach the key to a logged-in memgit cloud account')
+def pro_activate(key, no_cloud):
+    """Store KEY and validate it with Polar. Buy one at memgit.dev/#pricing."""
+    from . import license as lic_mod
+    from datetime import datetime, timezone
+    key = key.strip()
+    if len(key) < 8:
+        console.print('[red]✗[/red] that does not look like a licence key')
+        sys.exit(2)
+    lic = lic_mod.License(key=key)
+    now = datetime.now(timezone.utc)
+    lic = lic_mod.refresh(lic, now=now, force=True)
+    if lic.status == 'granted':
+        lic_mod.write(lic)
+        console.print(f'[green]✓[/green] memgit Pro activated for key {lic.masked}'
+                      + (f' ({lic.customer_email})' if lic.customer_email else ''))
+        if lic.expires_at:
+            console.print(f'  [dim]expires {lic.expires_at}[/dim]')
+    elif lic.status in ('revoked', 'disabled', 'invalid'):
+        console.print(f'[red]✗[/red] key {lic.masked} was rejected: {lic.error or lic.status}')
+        console.print('  [dim]Keys are issued by Polar on purchase and shown in your purchases page.[/dim]')
+        sys.exit(1)
+    else:  # unknown — offline or provider down: keep the key, verify on next run
+        lic.status = 'none'
+        lic_mod.write(lic)
+        console.print(f'[yellow]![/yellow] could not reach the licence service ({lic.error}); '
+                      f'key {lic.masked} saved and will be verified on the next run')
+    if not no_cloud and lic.status == 'granted':
+        _pro_attach_cloud(key)
+
+
+def _pro_attach_cloud(key: str) -> None:
+    """Best-effort: if this store is logged in to memgit cloud, tell the API about
+    the key so the hosted side unlocks too. Silent when not logged in."""
+    try:
+        from .cloud.state import CloudState
+        from .repo import Repository
+        repo = Repository.find()
+        if repo is None:
+            return
+        cstate = CloudState(repo.path)
+        creds = cstate.creds
+        if not creds.get('access'):
+            return
+        from .cloud.client import ApiClient, DEFAULT_API_URL
+        import os as _os
+        api_url = _os.environ.get('MEMGIT_CLOUD_API') or creds.get('api_url') or DEFAULT_API_URL
+        api = ApiClient(api_url, cstate)
+        api._check(api._request('POST', '/v1/billing/polar/activate', json={'license_key': key}))
+        console.print('[green]✓[/green] memgit cloud account upgraded to Pro')
+    except Exception as e:  # never let the hosted side break local activation
+        console.print(f'[dim]cloud: not attached ({str(e)[:80]}) — run `memgit cloud login` then re-activate[/dim]')
+
+
+@pro.command('status')
+@click.option('--json', 'fmt_json', is_flag=True, help='JSON output')
+@click.option('--offline', is_flag=True, help='Answer from the cache only; never touch the network')
+def pro_status(fmt_json, offline):
+    """Show whether this machine is entitled to memgit Pro."""
+    from . import license as lic_mod
+    from datetime import datetime, timezone
+    now = datetime.now(timezone.utc)
+    lic = lic_mod.read()
+    if lic.key and not offline and lic.needs_recheck(now):
+        lic = lic_mod.refresh(lic, now=now)
+        if lic.source == 'file':
+            try:
+                lic_mod.write(lic)
+            except OSError:
+                pass
+    ent = lic.is_entitled(now)
+    if fmt_json:
+        import json as _j
+        print(_j.dumps({'entitled': ent, 'key': lic.masked, 'status': lic.status,
+                        'validated_at': lic.validated_at, 'expires_at': lic.expires_at,
+                        'source': lic.source, 'error': lic.error}))
+        return
+    if not lic.key:
+        console.print('[bold]memgit Free[/bold] — no licence key. '
+                      f'Pro (hosted E2E sync across machines and teams): {lic_mod.PRO_URL}')
+        return
+    tier = '[green]memgit Pro[/green]' if ent else '[yellow]memgit Free (key not entitled)[/yellow]'
+    console.print(f'{tier}  key {lic.masked}  status {lic.status}'
+                  f'{"  via $MEMGIT_LICENSE_KEY" if lic.source != "file" else ""}')
+    if lic.validated_at:
+        console.print(f'  [dim]last verified {lic.validated_at}[/dim]')
+    if lic.expires_at:
+        console.print(f'  [dim]expires {lic.expires_at}[/dim]')
+    if lic.error:
+        console.print(f'  [yellow]{lic.error}[/yellow]')
+
+
+@pro.command('deactivate')
+def pro_deactivate():
+    """Remove the stored licence key from this machine."""
+    from . import license as lic_mod
+    if lic_mod.clear():
+        console.print('[green]✓[/green] licence key removed; memgit is back on the Free tier')
+    else:
+        console.print('[dim]no licence key was stored[/dim]')
+
+
 # ── cloud (E2E-encrypted team sync — optional extra) ──────────────────────────
 
 try:

memgit-0.10.0/memgit/license.py

@@ -0,0 +1,270 @@
+"""memgit Pro — licence-key entitlement, validated against Polar, cached locally.
+
+Design constraints (all deliberate):
+  * NO new dependency. Plain memgit stays `click + rich + mcp`; the check uses urllib.
+  * NOTHING about the store ever leaves the machine. The only bytes sent are the
+    licence key and our organisation id, to Polar's public validation endpoint.
+  * FAIL OPEN, bounded. A network failure never breaks a working install: a key
+    that validated within GRACE_DAYS keeps its entitlement; a key that has never
+    validated, or whose last good check is older than the grace window, is free.
+  * The key is never printed in full. `pro status` shows the last 4 characters.
+
+State lives OUTSIDE the store (a licence belongs to a person, not to a repo):
+    $MEMGIT_HOME/license.json   (default ~/.memgit/license.json, mode 0600)
+
+    {"key": "...", "activation_id": null, "status": "granted",
+     "validated_at": "2026-09-03T10:00:00+00:00", "expires_at": null,
+     "customer_email": null, "error": null}
+
+Entitlement is also readable from the environment for headless/MCP hosts:
+    MEMGIT_LICENSE_KEY=<key>   (validated with the same cache; never written to disk
+                               unless `memgit pro activate` is run explicitly)
+"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+
+POLAR_API = os.environ.get("MEMGIT_POLAR_API", "https://api.polar.sh")
+# Public identifier of the memgit organisation on Polar. Not a secret — it is the
+# same value every customer's client sends. Overridable so tests and a future
+# org migration never need a code change.
+POLAR_ORGANIZATION_ID = os.environ.get(
+    "MEMGIT_POLAR_ORG_ID", "1267be9a-acd0-4cdb-a3e4-0ee41134e87e"
+)
+
+GRACE_DAYS = 14          # keep entitlement this long after the last successful check
+RECHECK_HOURS = 24       # do not hit the network more often than this
+TIMEOUT_S = 6
+
+_LICENSE_FILE = "license.json"
+
+
+def home_dir() -> Path:
+    return Path(os.environ.get("MEMGIT_HOME") or (Path.home() / ".memgit"))
+
+
+def _path() -> Path:
+    return home_dir() / _LICENSE_FILE
+
+
+@dataclass
+class License:
+    key: str = ""
+    activation_id: Optional[str] = None
+    status: str = "none"              # none | granted | revoked | disabled | invalid | unknown
+    validated_at: Optional[str] = None
+    expires_at: Optional[str] = None
+    customer_email: Optional[str] = None
+    error: Optional[str] = None
+    source: str = "file"              # file | env
+    extra: dict = field(default_factory=dict)
+
+    # ── derived ────────────────────────────────────────────────────────────
+    @property
+    def masked(self) -> str:
+        k = self.key or ""
+        return ("…" + k[-4:]) if len(k) >= 4 else ("…" if k else "")
+
+    def _validated_dt(self) -> Optional[datetime]:
+        if not self.validated_at:
+            return None
+        try:
+            return datetime.fromisoformat(self.validated_at)
+        except ValueError:
+            return None
+
+    def _expires_dt(self) -> Optional[datetime]:
+        if not self.expires_at:
+            return None
+        try:
+            return datetime.fromisoformat(self.expires_at.replace("Z", "+00:00"))
+        except ValueError:
+            return None
+
+    def is_entitled(self, now: Optional[datetime] = None) -> bool:
+        """True when the last successful validation is within the grace window
+        and the key has not passed its own expiry. Never consults the network."""
+        now = now or datetime.now(timezone.utc)
+        if self.status != "granted":
+            return False
+        v = self._validated_dt()
+        if v is None or now - v > timedelta(days=GRACE_DAYS):
+            return False
+        e = self._expires_dt()
+        if e is not None and now > e:
+            return False
+        return True
+
+    def needs_recheck(self, now: Optional[datetime] = None) -> bool:
+        now = now or datetime.now(timezone.utc)
+        v = self._validated_dt()
+        return v is None or now - v > timedelta(hours=RECHECK_HOURS)
+
+
+# ── persistence ────────────────────────────────────────────────────────────
+
+def read() -> License:
+    """The stored licence, or the env-supplied one, or an empty record."""
+    p = _path()
+    data: dict = {}
+    if p.exists():
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            data = {}
+    lic = License(**{k: v for k, v in data.items() if k in License.__dataclass_fields__})
+    env_key = os.environ.get("MEMGIT_LICENSE_KEY", "").strip()
+    if env_key and env_key != lic.key:
+        # An env key overrides the file but inherits nothing from it.
+        lic = License(key=env_key, source="env")
+    elif env_key:
+        lic.source = "env+file"
+    return lic
+
+
+def write(lic: License) -> Path:
+    p = _path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    payload = {k: v for k, v in asdict(lic).items() if k != "source"}
+    tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    try:
+        os.chmod(tmp, 0o600)
+    except OSError:
+        pass
+    tmp.replace(p)
+    return p
+
+
+def clear() -> bool:
+    p = _path()
+    if p.exists():
+        p.unlink()
+        return True
+    return False
+
+
+# ── network ────────────────────────────────────────────────────────────────
+
+class ValidationResult(dict):
+    """Raw validate() outcome. Keys: ok (bool), status (str), http (int|None),
+    body (dict), error (str|None). `status` is one of granted/revoked/disabled/
+    invalid/unknown — 'unknown' means the network did not answer, not that the
+    key is bad."""
+
+
+def _post_json(url: str, payload: dict, timeout: float = TIMEOUT_S) -> tuple[int, dict]:
+    import urllib.error
+    import urllib.request
+    req = urllib.request.Request(
+        url, data=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json",
+                 "Accept": "application/json",
+                 "User-Agent": "memgit-pro/1"},
+        method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:  # noqa: S310 — fixed https host
+            return r.status, _safe_json(r.read())
+    except urllib.error.HTTPError as e:
+        try:
+            body = _safe_json(e.read())
+        except Exception:
+            body = {}
+        return e.code, body
+
+
+def _safe_json(raw: bytes) -> dict:
+    try:
+        v = json.loads(raw.decode("utf-8") or "{}")
+        return v if isinstance(v, dict) else {"value": v}
+    except (ValueError, UnicodeDecodeError):
+        return {}
+
+
+def validate(key: str, activation_id: Optional[str] = None,
+             org_id: Optional[str] = None, post=None) -> ValidationResult:
+    """Ask Polar whether `key` is granted. Pure function over `post` so tests can
+    substitute the transport; never raises."""
+    post = post or _post_json   # resolved at call time so tests can monkeypatch the module
+    org = org_id if org_id is not None else POLAR_ORGANIZATION_ID
+    if not key:
+        return ValidationResult(ok=False, status="invalid", http=None, body={}, error="no key")
+    if not org:
+        return ValidationResult(ok=False, status="unknown", http=None, body={},
+                                error="MEMGIT_POLAR_ORG_ID is not configured in this build")
+    payload = {"key": key, "organization_id": org}
+    if activation_id:
+        payload["activation_id"] = activation_id
+    try:
+        http, body = post(f"{POLAR_API}/v1/customer-portal/license-keys/validate", payload)
+    except Exception as e:  # DNS, TLS, timeout, offline
+        return ValidationResult(ok=False, status="unknown", http=None, body={}, error=str(e)[:200])
+    if http == 200:
+        st = str(body.get("status", "")).lower() or "granted"
+        return ValidationResult(ok=(st == "granted"), status=st if st in ("granted", "revoked", "disabled") else "invalid",
+                                http=http, body=body, error=None)
+    if http in (400, 403, 404, 422):
+        detail = body.get("detail") or body.get("error") or f"HTTP {http}"
+        return ValidationResult(ok=False, status="invalid", http=http, body=body,
+                                error=str(detail)[:200])
+    # 5xx / 429 / anything else: the provider did not answer the question
+    return ValidationResult(ok=False, status="unknown", http=http, body=body,
+                            error=f"provider returned HTTP {http}")
+
+
+def refresh(lic: License, now: Optional[datetime] = None, post=None,
+            force: bool = False) -> License:
+    """Validate when due and fold the answer into the record. Fail-open: an
+    'unknown' answer leaves the last good validation untouched."""
+    now = now or datetime.now(timezone.utc)
+    if not lic.key:
+        return lic
+    if not force and not lic.needs_recheck(now):
+        return lic
+    res = validate(lic.key, lic.activation_id, post=post)
+    if res["status"] == "unknown":
+        lic.error = res["error"]
+        return lic
+    lic.status = res["status"]
+    lic.error = None if res["ok"] else res["error"]
+    if res["ok"]:
+        lic.validated_at = now.isoformat()
+        body = res["body"]
+        lic.expires_at = body.get("expires_at")
+        cust = body.get("customer") or {}
+        lic.customer_email = cust.get("email") if isinstance(cust, dict) else None
+        lic.extra = {k: body.get(k) for k in ("usage", "limit_usage", "validations", "id") if k in body}
+    return lic
+
+
+# ── the one call everything else uses ─────────────────────────────────────
+
+def entitled(now: Optional[datetime] = None, allow_network: bool = True,
+             post=None) -> bool:
+    """Is this machine entitled to memgit Pro right now?
+
+    Cheap path: the cached record answers without the network. When a recheck
+    is due and the network is allowed, refresh (fail-open) and persist the
+    result for file-sourced keys. Never raises."""
+    try:
+        lic = read()
+        if not lic.key:
+            return False
+        if allow_network and lic.needs_recheck(now):
+            lic = refresh(lic, now=now, post=post)
+            if lic.source == "file":
+                try:
+                    write(lic)
+                except OSError:
+                    pass
+        return lic.is_entitled(now)
+    except Exception:
+        return False
+
+
+PRO_URL = "https://memgit.dev/#pricing"