memor-cli 0.7.1__tar.gz → 0.8.0__tar.gz

{memor_cli-0.7.1/memor_cli.egg-info → memor_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memor-cli
-Version: 0.7.1
+Version: 0.8.0
 Summary: Measured memory for coding agents. Fire and forget — no API keys needed.
 Author-email: Nimit Bhandari <nimitbhandari17@gmail.com>
 License-Expression: MIT
@@ -73,7 +73,7 @@ memor service install
 memor daemon
 ```
 
-That's it. Every prompt now gets automatic context recall. Open the dashboard to see it working:
+That's it. Every prompt now gets automatic context recall. `memor service install` also starts the dashboard as a background service, so it's already live at http://localhost:8420 (and is recycled whenever you stop/restart/uninstall the service). To run it in the foreground instead:
 
 ```bash
 memor dashboard
@@ -218,10 +218,13 @@ memor install-hook                   Install hook + download model (interactive
 memor daemon                         Auto-ingest + distill (background watcher)
 memor dashboard                      Web dashboard on localhost:8420
 memor version                        Print installed version
-memor service install                Run daemon as background service (launchd/systemd)
-memor service stop                   Stop the background service
-memor service uninstall              Remove the background service
-memor service status                 Check if the service is running
+memor service install                Run daemon + dashboard as background services (launchd/systemd)
+  --no-dashboard                     Install only the daemon
+memor service restart                Restart both services (use after `pipx upgrade`)
+memor service stop                   Stop both background services
+memor service uninstall              Remove both background services
+memor service status                 Show daemon + dashboard status
+  (dashboard port: set MEMOR_DASHBOARD_PORT, default 8420)
 memor query <text>                   Search memories from the CLI
 memor reingest                       Wipe DB and re-ingest everything
 memor reingest --project <name>      Re-ingest only one project
@@ -328,7 +331,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 287 tests
+pytest  # 298 tests
 ```
 
 ---

{memor_cli-0.7.1 → memor_cli-0.8.0}/README.md

@@ -36,7 +36,7 @@ memor service install
 memor daemon
 ```
 
-That's it. Every prompt now gets automatic context recall. Open the dashboard to see it working:
+That's it. Every prompt now gets automatic context recall. `memor service install` also starts the dashboard as a background service, so it's already live at http://localhost:8420 (and is recycled whenever you stop/restart/uninstall the service). To run it in the foreground instead:
 
 ```bash
 memor dashboard
@@ -181,10 +181,13 @@ memor install-hook                   Install hook + download model (interactive
 memor daemon                         Auto-ingest + distill (background watcher)
 memor dashboard                      Web dashboard on localhost:8420
 memor version                        Print installed version
-memor service install                Run daemon as background service (launchd/systemd)
-memor service stop                   Stop the background service
-memor service uninstall              Remove the background service
-memor service status                 Check if the service is running
+memor service install                Run daemon + dashboard as background services (launchd/systemd)
+  --no-dashboard                     Install only the daemon
+memor service restart                Restart both services (use after `pipx upgrade`)
+memor service stop                   Stop both background services
+memor service uninstall              Remove both background services
+memor service status                 Show daemon + dashboard status
+  (dashboard port: set MEMOR_DASHBOARD_PORT, default 8420)
 memor query <text>                   Search memories from the CLI
 memor reingest                       Wipe DB and re-ingest everything
 memor reingest --project <name>      Re-ingest only one project
@@ -291,7 +294,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 287 tests
+pytest  # 298 tests
 ```
 
 ---

memor_cli-0.8.0/memor/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

{memor_cli-0.7.1 → memor_cli-0.8.0}/memor/cli.py

@@ -46,15 +46,18 @@ memor — measured memory for coding agents
 GETTING STARTED
   memor install-hook            Install the recall hook + download model
     --agent claude|codex|copilot  Choose your agent (default: claude)
-  memor service install         Start the daemon as a background service
+  memor service install         Start the daemon + dashboard as background services
   memor dashboard               Open the web dashboard at localhost:8420
 
 SERVICE MANAGEMENT
-  memor service install     Install and start as a background service (survives reboots)
-  memor service status      Check if the daemon is running
-  memor service stop        Stop the service (restarts on next login)
-  memor service uninstall   Stop and remove the service completely
+  memor service install     Install/start daemon + dashboard (survives reboots)
+    --no-dashboard            Install only the daemon
+  memor service status      Show daemon + dashboard status
+  memor service restart     Restart both (use after `pipx upgrade`)
+  memor service stop        Stop both services (restart on next login)
+  memor service uninstall   Stop and remove both services completely
   memor daemon              Run the daemon in the foreground (alternative to service)
+  (dashboard port: set MEMOR_DASHBOARD_PORT, default 8420)
 
 QUERYING
   memor query <text>        Search memories from the command line
@@ -218,7 +221,7 @@ def eval_counterfactual_cmd(project: str = typer.Option(...), db: str = "memor.d
         import os
         llm = OpenAICompatLLM(base_url=os.environ.get("OPENAI_BASE_URL", "http://localhost:11434/v1"),
                               api_key=os.environ.get("OPENAI_API_KEY", ""), model=llm_model)
-    summary = run_suite(cases, store=s, embedder=e, llm=llm, k=k)
+    summary = run_suite(cases, store=s, embedder=e, llm=llm, db_path=_db_path(db), k=k)
     typer.echo(json.dumps({k: v for k, v in summary.items() if k != "cases"}, indent=2))
     typer.echo("")
     typer.echo(f"  Win:  {summary['win_count']}/{summary['n_cases']} ({summary['win_pct']}%)")
@@ -638,11 +641,14 @@ def version():
 
 
 @service_app.command("install")
-def service_install():
-    """Install and start the daemon as a background service (survives reboots)."""
+def service_install(
+    no_dashboard: bool = typer.Option(
+        False, "--no-dashboard", help="Install only the daemon, not the dashboard."),
+):
+    """Install and start the daemon + dashboard as background services (survives reboots)."""
     from memor.service import install
     try:
-        typer.echo(install())
+        typer.echo(install(with_dashboard=not no_dashboard))
     except FileNotFoundError as e:
         typer.echo(str(e), err=True)
         raise typer.Exit(1)
@@ -651,9 +657,23 @@ def service_install():
         raise typer.Exit(1)
 
 
+@service_app.command("restart")
+def service_restart():
+    """Restart both services (use after `pipx upgrade` to run the new version)."""
+    from memor.service import restart
+    try:
+        typer.echo(restart())
+    except FileNotFoundError as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.echo(f"Failed to restart service: {e}", err=True)
+        raise typer.Exit(1)
+
+
 @service_app.command("uninstall")
 def service_uninstall():
-    """Stop and remove the background service."""
+    """Stop and remove the background services (daemon + dashboard)."""
     from memor.service import uninstall
     typer.echo(uninstall())
 

{memor_cli-0.7.1 → memor_cli-0.8.0}/memor/eval/counterfactual.py

@@ -13,8 +13,7 @@ import re
 import time
 from dataclasses import dataclass
 
-from memor.types import Artifact, Scope
-from memor.retrieve.retriever import Retriever
+from memor.types import Artifact
 
 
 class Outcome(enum.Enum):
@@ -114,20 +113,38 @@ def parse_verdict_json(raw: str) -> CounterfactualVerdict:
     )
 
 
-def run_case(case: CounterfactualCase, *, store, embedder, llm,
+def run_case(case: CounterfactualCase, *, store, embedder, llm, db_path,
              k: int = 8) -> CounterfactualVerdict:
-    scope = Scope(project=case.scope_project)
-    r = Retriever(store, embedder, k=k)
-    trace = r.query(case.query, scope)
+    """Judge a case using the PRODUCTION recall() path, not a bare Retriever.
+
+    This mirrors what the hook actually injects: same-session exclusion,
+    the 0.3/0.15 score threshold, the per-tier token budget, and 600-char
+    truncation. Without this, the eval over-recalls (self-recall echoes and
+    sub-threshold hits production would never inject), inflating ties and
+    producing same-session "losses" that cannot happen in production.
+    """
+    from memor.query_complexity import route_query, Tier
+    from memor.recall import recall
+
+    tier = route_query(case.query)
+    if tier == Tier.SKIP:
+        return CounterfactualVerdict(
+            outcome=Outcome.TIE,
+            reasoning="Production routes this query to SKIP — no recall would occur",
+            confidence=1.0)
+
+    result = recall(case.query, case.scope_project, db_path, embedder=embedder,
+                    k=tier.k, threshold=0.15, max_tokens=tier.max_tokens,
+                    session_id=case.session_id)
 
-    if not trace.hits:
+    if not result.hit_ids:
         return CounterfactualVerdict(
             outcome=Outcome.TIE,
-            reasoning="No context recalled — nothing to evaluate",
+            reasoning="No context recalled via production path — nothing to evaluate",
             confidence=1.0)
 
-    recalled = "\n\n".join(
-        f"[{h.artifact.kind}] {h.artifact.text}" for h in trace.hits)
+    # Judge exactly what production injects (post-exclusion/threshold/budget/truncation).
+    recalled = result.formatted_context
     holdout = "\n".join(case.holdout_texts)
 
     prompt = COUNTERFACTUAL_PROMPT.format(
@@ -136,11 +153,14 @@ def run_case(case: CounterfactualCase, *, store, embedder, llm,
     return parse_verdict_json(raw)
 
 
-def run_suite(cases: list[CounterfactualCase], *, store, embedder, llm,
+def run_suite(cases: list[CounterfactualCase], *, store, embedder, llm, db_path,
               k: int = 8) -> dict:
     verdicts = []
-    for c in cases:
-        v = run_case(c, store=store, embedder=embedder, llm=llm, k=k)
+    n = len(cases)
+    for i, c in enumerate(cases, 1):
+        print(f"  [{i}/{n}] judging case...", end="", flush=True)
+        v = run_case(c, store=store, embedder=embedder, llm=llm, db_path=db_path, k=k)
+        print(f" {v.outcome.value}", flush=True)
         verdicts.append((c, v))
     verdict_list = [v for _, v in verdicts]
     summary = summarize_verdicts(verdict_list)

memor_cli-0.8.0/memor/llm/anthropic.py

@@ -0,0 +1,45 @@
+import time
+
+
+class AnthropicLLM:
+    def __init__(self, model: str = "claude-opus-4-8", api_key: str | None = None,
+                 *, max_retries: int = 8):
+        import anthropic
+
+        # Disable the SDK's own (silent) retries so our visible backoff below
+        # is the single source of waiting — otherwise the SDK sleeps on 429
+        # internally before raising, which looks like a hang.
+        self.client = anthropic.Anthropic(api_key=api_key, max_retries=0)
+        self.model = model
+        self.max_retries = max_retries
+
+    def complete(self, prompt: str, *, max_tokens: int = 1024) -> str:
+        import anthropic
+
+        attempt = 0
+        while True:
+            try:
+                msg = self.client.messages.create(
+                    model=self.model,
+                    max_tokens=max_tokens,
+                    messages=[{"role": "user", "content": prompt}],
+                )
+                return "".join(b.text for b in msg.content if b.type == "text")
+            except anthropic.RateLimitError as e:
+                attempt += 1
+                if attempt > self.max_retries:
+                    raise
+                # Honor Retry-After when present; otherwise wait out the
+                # per-minute token window (tier-1 limits reset each minute).
+                wait = _retry_after_seconds(e) or 60
+                print(f"  rate limited (429); waiting {wait}s then retrying "
+                      f"(attempt {attempt}/{self.max_retries})...", flush=True)
+                time.sleep(wait)
+
+
+def _retry_after_seconds(err) -> float | None:
+    try:
+        val = err.response.headers.get("retry-after")
+        return float(val) if val is not None else None
+    except Exception:
+        return None

memor_cli-0.8.0/memor/service.py

@@ -0,0 +1,297 @@
+"""Manage memor background services (daemon + dashboard) as launchd (macOS)
+or systemd (Linux) user services.
+
+Two units are managed together so they cycle in lockstep:
+  - daemon    (ai.memor.daemon)    — ingest + distill
+  - dashboard (ai.memor.dashboard) — web UI on MEMOR_DASHBOARD_PORT (default 8420)
+
+install/stop/uninstall/status/restart all operate on both units, so stopping or
+reinstalling recycles the dashboard alongside the daemon. `install(with_dashboard=False)`
+installs the daemon only.
+"""
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+import textwrap
+from pathlib import Path
+
+DAEMON_LABEL = "ai.memor.daemon"
+DASHBOARD_LABEL = "ai.memor.dashboard"
+# Back-compat alias.
+LABEL = DAEMON_LABEL
+
+STATE_DIR = Path.home() / ".memor"
+DAEMON_LOG = STATE_DIR / "daemon.log"
+DASHBOARD_LOG = STATE_DIR / "dashboard.log"
+LOG_FILE = DAEMON_LOG  # back-compat alias
+
+# macOS
+PLIST_DIR = Path.home() / "Library" / "LaunchAgents"
+# Linux
+SYSTEMD_DIR = Path.home() / ".config" / "systemd" / "user"
+
+DEFAULT_DASHBOARD_PORT = 8420
+
+
+def _is_macos() -> bool:
+    return platform.system() == "Darwin"
+
+
+def _find_memor_bin() -> str:
+    path = shutil.which("memor")
+    if not path:
+        raise FileNotFoundError(
+            "'memor' not found on PATH. Reinstall with: pipx install memor-cli"
+        )
+    return path
+
+
+def _dashboard_port() -> int:
+    try:
+        p = int(os.environ.get("MEMOR_DASHBOARD_PORT", str(DEFAULT_DASHBOARD_PORT)))
+        return p if p > 0 else DEFAULT_DASHBOARD_PORT
+    except (ValueError, TypeError):
+        return DEFAULT_DASHBOARD_PORT
+
+
+def _units(memor_bin: str, *, with_dashboard: bool = True, port: int | None = None) -> list[dict]:
+    """Describe the services to manage. Each entry has the launchd label,
+    systemd unit name, program args (after the memor binary), and log file."""
+    if port is None:
+        port = _dashboard_port()
+    units = [{
+        "key": "daemon",
+        "label": DAEMON_LABEL,
+        "systemd_name": "memor-daemon",
+        "description": "Memor daemon — memory layer for coding agents",
+        "args": [memor_bin, "daemon"],
+        "log": DAEMON_LOG,
+    }]
+    if with_dashboard:
+        units.append({
+            "key": "dashboard",
+            "label": DASHBOARD_LABEL,
+            "systemd_name": "memor-dashboard",
+            "description": "Memor dashboard — web UI for memory metrics",
+            "args": [memor_bin, "dashboard", "--port", str(port), "--no-open"],
+            "log": DASHBOARD_LOG,
+        })
+    return units
+
+
+def _all_unit_labels() -> list[tuple[str, str]]:
+    """(launchd label, systemd name) for every unit we might have installed,
+    used by uninstall/stop/status which must act regardless of with_dashboard."""
+    return [(DAEMON_LABEL, "memor-daemon"), (DASHBOARD_LABEL, "memor-dashboard")]
+
+
+def _plist_path(label: str) -> Path:
+    return PLIST_DIR / f"{label}.plist"
+
+
+def _unit_path(systemd_name: str) -> Path:
+    return SYSTEMD_DIR / f"{systemd_name}.service"
+
+
+def _plist_content(label: str, args, log_file) -> str:
+    if isinstance(args, str):  # back-compat: old callers passed just the memor bin
+        args = [args, "daemon"]
+    arg_xml = "\n".join(f"                <string>{a}</string>" for a in args)
+    return textwrap.dedent(f"""\
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>Label</key>
+            <string>{label}</string>
+            <key>ProgramArguments</key>
+            <array>
+{arg_xml}
+            </array>
+            <key>RunAtLoad</key>
+            <true/>
+            <key>KeepAlive</key>
+            <true/>
+            <key>StandardOutPath</key>
+            <string>{log_file}</string>
+            <key>StandardErrorPath</key>
+            <string>{log_file}</string>
+            <key>ProcessType</key>
+            <string>Background</string>
+        </dict>
+        </plist>
+    """)
+
+
+def _systemd_unit(label, description="Memor daemon — memory layer for coding agents",
+                  args=None, log_file=LOG_FILE) -> str:
+    if args is None:  # back-compat: old signature was _systemd_unit(memor_bin)
+        args = [label, "daemon"]
+    exec_start = " ".join(str(a) for a in args)
+    return textwrap.dedent(f"""\
+        [Unit]
+        Description={description}
+        After=default.target
+
+        [Service]
+        Type=simple
+        ExecStart={exec_start}
+        Restart=on-failure
+        RestartSec=10
+        StandardOutput=append:{log_file}
+        StandardError=append:{log_file}
+
+        [Install]
+        WantedBy=default.target
+    """)
+
+
+def _port_in_use(port: int) -> bool:
+    import socket
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(0.2)
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+
+def install(with_dashboard: bool = True) -> str:
+    memor_bin = _find_memor_bin()
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    port = _dashboard_port()
+    units = _units(memor_bin, with_dashboard=with_dashboard, port=port)
+
+    warnings = []
+    if with_dashboard and _port_in_use(port):
+        warnings.append(
+            f"  warning: port {port} is already in use — the dashboard service may "
+            f"crash-loop. Stop the other process or set MEMOR_DASHBOARD_PORT.")
+
+    lines = []
+    if _is_macos():
+        PLIST_DIR.mkdir(parents=True, exist_ok=True)
+        for u in units:
+            path = _plist_path(u["label"])
+            path.write_text(_plist_content(u["label"], u["args"], u["log"]))
+            subprocess.run(["launchctl", "bootout", f"gui/{os.getuid()}", str(path)],
+                           capture_output=True)
+            subprocess.run(["launchctl", "bootstrap", f"gui/{os.getuid()}", str(path)],
+                           check=True)
+            lines.append(f"  {u['key']}: {path}")
+        header = "Installed and started launchd services:"
+    else:
+        SYSTEMD_DIR.mkdir(parents=True, exist_ok=True)
+        for u in units:
+            path = _unit_path(u["systemd_name"])
+            path.write_text(_systemd_unit(u["label"], u["description"], u["args"], u["log"]))
+            lines.append(f"  {u['key']}: {path}")
+        subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
+        for u in units:
+            subprocess.run(["systemctl", "--user", "enable", "--now", u["systemd_name"]],
+                           check=True)
+        header = "Installed and started systemd user services:"
+
+    out = [header, *lines]
+    if with_dashboard:
+        out.append(f"  dashboard: http://localhost:{port}")
+    if warnings:
+        out.extend(warnings)
+    return "\n".join(out)
+
+
+def uninstall() -> str:
+    removed = []
+    if _is_macos():
+        for label, _ in _all_unit_labels():
+            path = _plist_path(label)
+            if path.exists():
+                subprocess.run(["launchctl", "bootout", f"gui/{os.getuid()}", str(path)],
+                               capture_output=True)
+                path.unlink()
+                removed.append(str(path))
+    else:
+        changed = False
+        for _, name in _all_unit_labels():
+            path = _unit_path(name)
+            if path.exists():
+                subprocess.run(["systemctl", "--user", "disable", "--now", name],
+                               capture_output=True)
+                path.unlink()
+                removed.append(str(path))
+                changed = True
+        if changed:
+            subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    if not removed:
+        return "No services installed."
+    return "Services stopped and removed:\n" + "\n".join(f"  deleted: {p}" for p in removed)
+
+
+def stop() -> str:
+    stopped = []
+    if _is_macos():
+        for label, _ in _all_unit_labels():
+            path = _plist_path(label)
+            if path.exists():
+                r = subprocess.run(["launchctl", "bootout", f"gui/{os.getuid()}", str(path)],
+                                   capture_output=True, text=True)
+                stopped.append(label if r.returncode == 0 else f"{label} (failed)")
+    else:
+        for _, name in _all_unit_labels():
+            if _unit_path(name).exists():
+                r = subprocess.run(["systemctl", "--user", "stop", name],
+                                   capture_output=True, text=True)
+                stopped.append(name if r.returncode == 0 else f"{name} (failed)")
+    if not stopped:
+        return "No services installed. Nothing to stop."
+    return ("Stopped: " + ", ".join(stopped) +
+            "\n  They restart on next login. To remove: memor service uninstall")
+
+
+def restart() -> str:
+    """Stop and reinstall both units — use after `pipx upgrade` to recycle them
+    onto the new binary (the running processes keep old code until restarted)."""
+    stop()
+    return install()
+
+
+def _macos_unit_status(label: str) -> str:
+    path = _plist_path(label)
+    if not path.exists():
+        return "not installed"
+    r = subprocess.run(["launchctl", "print", f"gui/{os.getuid()}/{label}"],
+                       capture_output=True, text=True)
+    if r.returncode != 0:
+        return "installed, not running"
+    for line in r.stdout.splitlines():
+        s = line.strip()
+        if s.startswith("pid ="):
+            return f"running (pid {s.split('=')[1].strip()})"
+    return "running"
+
+
+def _linux_unit_status(name: str) -> str:
+    if not _unit_path(name).exists():
+        return "not installed"
+    r = subprocess.run(["systemctl", "--user", "is-active", name],
+                       capture_output=True, text=True)
+    state = r.stdout.strip()
+    if state == "active":
+        pid_r = subprocess.run(["systemctl", "--user", "show", "-p", "MainPID", name],
+                               capture_output=True, text=True)
+        return f"running (pid {pid_r.stdout.strip().split('=')[-1]})"
+    return f"installed, {state}"
+
+
+def status() -> str:
+    rows = []
+    for label, name in _all_unit_labels():
+        key = "daemon" if label == DAEMON_LABEL else "dashboard"
+        st = _macos_unit_status(label) if _is_macos() else _linux_unit_status(name)
+        if key == "dashboard" and st.startswith("running"):
+            st += f" → http://localhost:{_dashboard_port()}"
+        rows.append(f"  {key}: {st}")
+    if all("not installed" in r for r in rows):
+        return "Not installed. Run: memor service install"
+    return "Service status:\n" + "\n".join(rows)

{memor_cli-0.7.1 → memor_cli-0.8.0/memor_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memor-cli
-Version: 0.7.1
+Version: 0.8.0
 Summary: Measured memory for coding agents. Fire and forget — no API keys needed.
 Author-email: Nimit Bhandari <nimitbhandari17@gmail.com>
 License-Expression: MIT
@@ -73,7 +73,7 @@ memor service install
 memor daemon
 ```
 
-That's it. Every prompt now gets automatic context recall. Open the dashboard to see it working:
+That's it. Every prompt now gets automatic context recall. `memor service install` also starts the dashboard as a background service, so it's already live at http://localhost:8420 (and is recycled whenever you stop/restart/uninstall the service). To run it in the foreground instead:
 
 ```bash
 memor dashboard
@@ -218,10 +218,13 @@ memor install-hook                   Install hook + download model (interactive
 memor daemon                         Auto-ingest + distill (background watcher)
 memor dashboard                      Web dashboard on localhost:8420
 memor version                        Print installed version
-memor service install                Run daemon as background service (launchd/systemd)
-memor service stop                   Stop the background service
-memor service uninstall              Remove the background service
-memor service status                 Check if the service is running
+memor service install                Run daemon + dashboard as background services (launchd/systemd)
+  --no-dashboard                     Install only the daemon
+memor service restart                Restart both services (use after `pipx upgrade`)
+memor service stop                   Stop both background services
+memor service uninstall              Remove both background services
+memor service status                 Show daemon + dashboard status
+  (dashboard port: set MEMOR_DASHBOARD_PORT, default 8420)
 memor query <text>                   Search memories from the CLI
 memor reingest                       Wipe DB and re-ingest everything
 memor reingest --project <name>      Re-ingest only one project
@@ -328,7 +331,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 287 tests
+pytest  # 298 tests
 ```
 
 ---

{memor_cli-0.7.1 → memor_cli-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memor-cli"
-version = "0.7.1"
+version = "0.8.0"
 description = "Measured memory for coding agents. Fire and forget — no API keys needed."
 readme = "README.md"
 license = "MIT"