mnemo-claude 0.12.0__py3-none-any.whl

mnemo/__init__.py

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

mnemo/__main__.py

@@ -0,0 +1,4 @@
+from mnemo.cli import main
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

mnemo/cli/__init__.py

@@ -0,0 +1,31 @@
+"""Backwards-compat shim for ``mnemo.cli`` (v0.9 PR H).
+
+The 1294-line ``cli.py`` was split into a package in v0.9 PR H. This
+shim re-exports the names the public API surface test pins
+(``main``, ``COMMANDS``, ``_resolve_vault``), the symbols every
+``cmd_*`` looks up at call-time so monkeypatch.setattr against
+``mnemo.cli.<name>`` propagates (``_resolve_vault``, ``_run_open``),
+and the three ``_doctor_check_reflex_*`` helpers
+``test_cli_status_doctor_reflex`` reads as attributes of
+``mnemo.cli``. Importing the ``commands`` submodule also triggers
+each ``@command`` decorator so the ``COMMANDS`` registry is
+populated by package-load time.
+
+New code should import from concrete submodules
+(``mnemo.cli.runtime``, ``mnemo.cli.commands.<name>``,
+``mnemo.cli.commands.doctor_checks.<concern>``).
+"""
+from __future__ import annotations
+
+from mnemo.cli import commands  # noqa: F401  — trigger @command registration
+from mnemo.cli.commands.doctor_checks.reflex import (  # noqa: F401
+    _doctor_check_reflex_bilingual_gap,
+    _doctor_check_reflex_index,
+    _doctor_check_reflex_session_cap_hits,
+)
+from mnemo.cli.parser import COMMANDS  # noqa: F401
+from mnemo.cli.runtime import (  # noqa: F401
+    _resolve_vault,
+    _run_open,
+    main,
+)

mnemo/cli/_helpers/__init__.py

@@ -0,0 +1,80 @@
+"""Small CLI-local helpers used by the status / doctor commands.
+
+Absorbs the v0.9 PR-A flat module ``mnemo.cli_helpers`` (81L) into the
+package layout introduced by PR H. Pure functions only — no argparse
+wiring — kept independently importable so the helpers stay
+unit-testable without booting the full CLI.
+
+Zero behavior change vs. the previous ``mnemo.cli_helpers`` module.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _read_jsonl_tail(path: Path, max_lines: int) -> list[dict]:
+    """Return the last *max_lines* decoded JSON objects from *path*.
+
+    Unified implementation behind :func:`_read_denial_log_tail` and
+    :func:`_read_enrichment_log_tail`. Blank lines and malformed JSON
+    lines are skipped silently. Any read error (missing file, decode
+    failure, permission) yields an empty list — callers treat the log
+    as advisory data, never a hard dependency.
+    """
+    try:
+        if not path.exists():
+            return []
+        text = path.read_text(encoding="utf-8", errors="replace")
+        lines = text.splitlines()
+        if len(lines) > max_lines:
+            lines = lines[-max_lines:]
+        entries: list[dict] = []
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+        return entries
+    except Exception:
+        return []
+
+
+def _read_denial_log_tail(vault: Path, max_lines: int = 1000) -> list[dict]:
+    """Read last *max_lines* from denial-log.jsonl. Returns [] on any error."""
+    return _read_jsonl_tail(vault / ".mnemo" / "denial-log.jsonl", max_lines)
+
+
+def _read_enrichment_log_tail(vault: Path, max_lines: int = 1000) -> list[dict]:
+    """Read last *max_lines* from enrichment-log.jsonl. Returns [] on any error."""
+    return _read_jsonl_tail(vault / ".mnemo" / "enrichment-log.jsonl", max_lines)
+
+
+def _count_today_denial_entries(entries: list[dict]) -> int:
+    """Count entries whose timestamp starts with today's date (UTC)."""
+    today_prefix = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    return sum(
+        1 for e in entries
+        if isinstance(e.get("timestamp"), str) and e["timestamp"].startswith(today_prefix)
+    )
+
+
+def _synthesize_path_for_glob(glob_pattern: str) -> str | None:
+    """Produce a concrete file path that should match the glob, or None.
+
+    Deterministic replacements:
+      ``**/`` -> ``a/``   (match-zero-or-more-segments case)
+      ``**``  -> ``a``    (trailing double-star)
+      ``*``   -> ``sample`` (single segment)
+    Returns None when the glob contains character classes or ``?`` — those
+    cannot be safely synthesized without guessing which characters the author
+    intended to match.
+    """
+    if "?" in glob_pattern or "[" in glob_pattern:
+        return None
+    out = glob_pattern.replace("**/", "a/").replace("**", "a").replace("*", "sample")
+    return out or None

mnemo/cli/commands/__init__.py

@@ -0,0 +1,25 @@
+"""Command sub-package — one module per CLI command.
+
+Each module decorates its handler with ``@command("<name>")`` from
+:mod:`mnemo.cli.parser`. The decorator runs at import time, so we
+must import every command module here for the registry to be
+populated by the time :func:`mnemo.cli.runtime.main` looks up a
+handler.
+"""
+from __future__ import annotations
+
+from mnemo.cli.commands import (  # noqa: F401  — trigger @command registration
+    briefing,
+    dedup_rules,
+    disable_rule,
+    doctor,
+    extract,
+    init,
+    list_enforced,
+    migrate_worktree_briefings,
+    misc,
+    recall,
+    statusline,
+    status,
+    telemetry,
+)

mnemo/cli/commands/briefing.py

@@ -0,0 +1,35 @@
+"""``mnemo briefing`` — hidden CLI hook invoked by session_end's detached spawn."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from mnemo.cli.parser import command
+
+
+@command("briefing")
+def cmd_briefing(args: argparse.Namespace) -> int:
+    """Hidden CLI entry point: `mnemo briefing <jsonl_path> <agent>`.
+
+    Invoked by session_end's detached spawn. Fire-and-forget: errors are
+    logged to ~/.errors.log under the vault but never propagated.
+    """
+    import contextlib
+    import os
+    from mnemo.core import briefing as briefing_mod, config as cfg_mod, errors as err_mod, paths
+
+    cfg = cfg_mod.load_config()
+    vault_root = paths.vault_root(cfg)
+    devnull = open(os.devnull, "w")
+    try:
+        with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
+            try:
+                briefing_mod.generate_session_briefing(
+                    Path(args.jsonl_path), args.agent, cfg,
+                )
+            except Exception as exc:
+                err_mod.log_error(vault_root, "briefing.cli", exc)
+                return 1
+    finally:
+        devnull.close()
+    return 0

mnemo/cli/commands/dedup_rules.py

@@ -0,0 +1,44 @@
+"""`mnemo dedup-rules` — consolidate shared/*.md files sharing the same `name:`.
+
+Dry-run by default (like `migrate-worktree-briefings`). Use `--apply` to
+execute the plan: canonical = most sources[] (tie → newer extracted_at);
+duplicates deleted; sources[] + frontmatter project(s) unioned on canonical.
+"""
+from __future__ import annotations
+
+import argparse
+
+from mnemo.cli.parser import command
+
+
+@command("dedup-rules")
+def cmd_dedup_rules(args: argparse.Namespace) -> int:
+    from mnemo import cli
+    from mnemo.core.dedup_rules import plan_dedup
+    from mnemo.core.filters import parse_frontmatter
+
+    vault = cli._resolve_vault()
+    plan = plan_dedup(vault)
+
+    if not plan.groups:
+        print("no duplicates found")
+        return 0
+
+    print(f"{len(plan.groups)} group(s) with duplicate names:\n")
+    for g in plan.groups:
+        canon_fm = parse_frontmatter(g.canonical.read_text(encoding="utf-8"))
+        name = canon_fm.get("name", "")
+        canon_rel = g.canonical.relative_to(vault)
+        dup_rels = ", ".join(p.name for p in g.duplicates)
+        print(f"  '{name}'")
+        print(f"    keep:   {canon_rel}")
+        print(f"    delete: {dup_rels}")
+        print(f"    merged_sources: {len(g.merged_sources)}  projects: {g.merged_projects}")
+
+    if not getattr(args, "apply", False):
+        print("\n(dry-run — pass --apply to execute)")
+        return 0
+
+    plan.apply()
+    print("\napplied.")
+    return 0

mnemo/cli/commands/disable_rule.py

@@ -0,0 +1,62 @@
+"""`mnemo disable-rule <slug>` — flip runtime: false on a rule's frontmatter."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from mnemo.cli.parser import command
+from mnemo.core import config, paths
+from mnemo.core.filters import derive_rule_slug, parse_frontmatter
+
+
+def _find_rule_file(vault_root: Path, slug: str) -> Path | None:
+    shared = vault_root / "shared"
+    if not shared.is_dir():
+        return None
+    for md in shared.rglob("*.md"):
+        # Match by filesystem stem first (most reliable for slug-as-filename)
+        if md.stem == slug:
+            return md
+        # Also match by derive_rule_slug in case frontmatter slug/name matches
+        try:
+            text = md.read_text()
+        except OSError:
+            continue
+        fm = parse_frontmatter(text)
+        if fm and derive_rule_slug(fm, md.stem) == slug:
+            return md
+    return None
+
+
+def run_disable_rule(vault_root: Path, *, slug: str) -> int:
+    md = _find_rule_file(vault_root, slug)
+    if md is None:
+        print(f"error: rule not found for slug {slug!r}", file=sys.stderr)
+        return 2
+    text = md.read_text()
+    if not text.startswith("---\n"):
+        print(f"error: {md} has no frontmatter", file=sys.stderr)
+        return 2
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        print(f"error: {md} frontmatter not closed", file=sys.stderr)
+        return 2
+    fm_block = text[4:end]
+    body = text[end + 5:]
+    if "\nruntime: false" in "\n" + fm_block or fm_block.startswith("runtime: false"):
+        print(f"already disabled: {md.relative_to(vault_root)}")
+        return 0
+    fm_lines = [ln for ln in fm_block.splitlines() if ln.strip() != "runtime: true"]
+    fm_lines.append("runtime: false")
+    new_text = "---\n" + "\n".join(fm_lines) + "\n---\n" + body
+    md.write_text(new_text)
+    print(f"disabled: {md.relative_to(vault_root)}")
+    return 0
+
+
+@command("disable-rule")
+def _cmd(ns: argparse.Namespace) -> int:
+    cfg = config.load_config()
+    vault = paths.vault_root(cfg)
+    return run_disable_rule(vault, slug=ns.slug)

mnemo/cli/commands/doctor.py

@@ -0,0 +1,124 @@
+"""``mnemo doctor`` — preflight + a registry of doctor checks.
+
+PR H of the v0.9 refactor roadmap converted ``cmd_doctor`` from a
+hardcoded and-chain of 11 calls into an OCP-compliant
+``DOCTOR_CHECKS: list[tuple[name, callable]]`` registry. Adding a new
+check is now a new row, not an edit to ``cmd_doctor``.
+"""
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from pathlib import Path
+
+from mnemo.cli.commands.doctor_checks import (
+    activation,
+    fidelity,
+    misc as doctor_misc,
+    orphan_worktree_briefings,
+    reflex,
+    rules,
+)
+from mnemo.cli.parser import command
+
+# Registry: (display_name, check_fn). Order matters — it matches the
+# original cmd_doctor invocation order in the v0.8.x cli.py monolith
+# (lines 402-413). ``_doctor_check_universal_promotion`` always returns
+# True today (advisory-only), so the ``if ok is False`` guard below is
+# robust to either bool or None return values.
+DOCTOR_CHECKS: list[tuple[str, Callable[[Path], bool]]] = [
+    ("auto_brain",            doctor_misc._doctor_check_auto_brain),
+    ("legacy_wiki_dirs",      doctor_misc._doctor_check_legacy_wiki_dirs),
+    ("statusline_drift",      reflex._doctor_check_statusline_drift),
+    ("activation",            activation._doctor_check_activation),
+    ("zero_hit",              fidelity._doctor_check_zero_hit),
+    ("activation_fidelity",   activation._doctor_check_activation_fidelity),
+    ("rule_integrity",        rules._doctor_check_rule_integrity),
+    ("reflex_index",          reflex._doctor_check_reflex_index),
+    ("reflex_session_cap",    reflex._doctor_check_reflex_session_cap_hits),
+    ("reflex_bilingual",      reflex._doctor_check_reflex_bilingual_gap),
+    ("orphan_worktree_briefings", orphan_worktree_briefings._doctor_check_orphan_worktree_briefings),
+    ("universal_promotion",   rules._doctor_check_universal_promotion),
+    ("bare_deny_command",     rules._doctor_check_bare_deny_command),
+    ("stripped_enforce",      rules._doctor_check_stripped_enforce),
+]
+
+
+def _detect_install_scope() -> str:
+    """Return 'project', 'global', 'both', or 'none' based on settings files present."""
+    import os
+    project = (Path.cwd() / ".claude" / "settings.json").exists()
+    global_ = Path(os.path.expanduser("~/.claude/settings.json")).exists()
+    if project and global_:
+        return "both"
+    if project:
+        return "project"
+    if global_:
+        return "global"
+    return "none"
+
+
+@command("doctor")
+def cmd_doctor(_args: argparse.Namespace) -> int:
+    from mnemo import cli  # late binding for monkeypatched _resolve_vault
+    from mnemo.install import preflight
+
+    vault = cli._resolve_vault()
+    scope = _detect_install_scope()
+    if scope == "project":
+        print(f"Install scope: project (local) — {Path.cwd()}")
+    elif scope == "global":
+        print("Install scope: global — ~/.claude/settings.json")
+    elif scope == "both":
+        print(f"Install scope: project (local) + global — {Path.cwd()} and ~/.claude/")
+    else:
+        print("Install scope: not installed")
+    print("Running diagnostic / preflight checks…")
+    result = preflight.run_preflight(vault_root=vault)
+    for issue in result.issues:
+        print(f"  [{issue.severity}] {issue.kind}: {issue.message}")
+        print(f"       → {issue.remediation}")
+
+    all_ok = True
+    for _name, check_fn in DOCTOR_CHECKS:
+        ok = check_fn(vault)
+        # universal_promotion is advisory and effectively always-True today;
+        # treat None (or any non-False return) as "not a warning".
+        if ok is False:
+            all_ok = False
+
+    _doctor_report_recall(vault)
+
+    if not result.ok:
+        print("Issues found above.")
+        return 1
+    if not all_ok:
+        print("Warnings above.")
+    else:
+        print("OK")
+    return 0
+
+
+def _doctor_report_recall(vault: Path) -> None:
+    """Emit one informational line from `.mnemo/recall-report.json` if present.
+
+    Purely advisory — never turns doctor into a warning/error, since the recall
+    suite is opt-in and the primacy rate is a trend indicator, not a pass/fail
+    gate. Silent when the report is missing, malformed, or empty.
+    """
+    import json as _json
+    path = vault / ".mnemo" / "recall-report.json"
+    if not path.is_file():
+        return
+    try:
+        data = _json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, _json.JSONDecodeError):
+        return
+    report = (data.get("report") or {}) if isinstance(data, dict) else {}
+    cases = report.get("cases", 0) or 0
+    rate = report.get("primacy_rate_at_5")
+    if cases == 0 or rate is None:
+        return
+    ts = data.get("generated_at")
+    suffix = f" (measured {ts})" if ts else ""
+    print(f"  ℹ Recall: primacy@5 = {rate:.1%} over {cases} cases{suffix}")

mnemo/cli/commands/doctor_checks/__init__.py

@@ -0,0 +1,30 @@
+"""Doctor-check sub-package — one module per concern.
+
+Each public ``_doctor_check_*`` function is registered in
+``cli.commands.doctor.DOCTOR_CHECKS`` (an OCP-compliant
+``list[tuple[name, callable]]``); adding a new check is a new
+row, not an edit to ``cmd_doctor``.
+"""
+from __future__ import annotations
+
+from mnemo.cli.commands.doctor_checks.activation import (  # noqa: F401
+    _doctor_check_activation,
+    _doctor_check_activation_fidelity,
+)
+from mnemo.cli.commands.doctor_checks.fidelity import (  # noqa: F401
+    _doctor_check_zero_hit,
+)
+from mnemo.cli.commands.doctor_checks.misc import (  # noqa: F401
+    _doctor_check_auto_brain,
+    _doctor_check_legacy_wiki_dirs,
+)
+from mnemo.cli.commands.doctor_checks.reflex import (  # noqa: F401
+    _doctor_check_reflex_bilingual_gap,
+    _doctor_check_reflex_index,
+    _doctor_check_reflex_session_cap_hits,
+    _doctor_check_statusline_drift,
+)
+from mnemo.cli.commands.doctor_checks.rules import (  # noqa: F401
+    _doctor_check_rule_integrity,
+    _doctor_check_universal_promotion,
+)

mnemo/cli/commands/doctor_checks/activation.py

@@ -0,0 +1,211 @@
+"""Activation-related doctor checks.
+
+Hosts :func:`_doctor_check_activation` (malformed/stale/over-broad
+activation blocks) and :func:`_doctor_check_activation_fidelity`
+(positive round-trip self-check that every enforce/activates_on rule
+reaches the index and self-activates on a synthesized path).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from mnemo.cli._helpers import _synthesize_path_for_glob
+
+
+def _doctor_check_activation_fidelity(vault: Path) -> bool:
+    """Positive self-check: every enforce/activates_on rule reaches the index
+    and its globs actually match a synthesized path.
+
+    Complements `_doctor_check_activation` (which validates malformed blocks)
+    with a round-trip: if the frontmatter parses but the slug never enters the
+    index or never self-activates on a representative path, something broke
+    between authoring and dispatch.
+
+    Returns True iff no warnings were emitted. `ℹ` info lines (for rules whose
+    globs are un-synthesizable) are NOT warnings.
+    """
+    from mnemo.core.filters import derive_rule_slug, parse_frontmatter
+    from mnemo.core.rule_activation import (
+        load_index,
+        match_path_enrich,
+        parse_activates_on_block,
+        parse_enforce_block,
+    )
+
+    index = load_index(vault)
+    if index is None:
+        return True  # no index yet; _doctor_check_activation surfaces staleness
+
+    indexed_slugs: set[str] = {
+        slug for slug, rule in index.get("rules", {}).items()
+        if rule.get("enforce") or rule.get("activates_on")
+    }
+
+    ok = True
+
+    feedback_dir = vault / "shared" / "feedback"
+    if feedback_dir.is_dir():
+        for md_path in sorted(feedback_dir.glob("*.md")):
+            try:
+                text = md_path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            try:
+                fm = parse_frontmatter(text)
+            except Exception:
+                continue
+
+            slug = derive_rule_slug(fm, md_path.stem)
+            rel = md_path.name
+
+            _parsed_enforce, _enforce_err = parse_enforce_block(fm)
+            has_enforce = _parsed_enforce is not None
+            has_enrich = parse_activates_on_block(fm) is not None
+
+            if has_enforce and slug not in indexed_slugs:
+                print(f"  \u26a0 Rule {rel!r} has a valid enforce block but is absent from the activation index")
+                print(f"       \u2192 run 'mnemo extract' to rebuild the index")
+                ok = False
+            if has_enrich and slug not in indexed_slugs:
+                print(f"  \u26a0 Rule {rel!r} has a valid activates_on block but is absent from the activation index")
+                print(f"       \u2192 run 'mnemo extract' to rebuild the index")
+                ok = False
+
+    for slug, rule_entry in index.get("rules", {}).items():
+        activates = rule_entry.get("activates_on")
+        if not activates:
+            continue
+        # Use first associated project for self-activation test; universal rules
+        # are reachable from any project so we just pick one from by_project.
+        rule_projects = rule_entry.get("projects", [])
+        project = rule_projects[0] if rule_projects else ""
+        globs = activates.get("path_globs", []) or []
+        tools = activates.get("tools", []) or []
+        if not globs or not tools:
+            continue
+        any_testable = False
+        mismatched = False
+        for glob in globs:
+            sample = _synthesize_path_for_glob(glob)
+            if sample is None:
+                continue
+            any_testable = True
+            for tool in tools:
+                hits = match_path_enrich(index, project, sample, tool)
+                if slug not in [h.slug for h in hits]:
+                    print(f"  \u26a0 Rule {slug!r} does not self-activate: glob {glob!r} -> synthesized {sample!r}, tool {tool!r} returned no hit")
+                    print(f"       \u2192 review the glob shape or the enrich build pipeline")
+                    ok = False
+                    mismatched = True
+                    break
+            if mismatched:
+                break
+        if not any_testable and not mismatched:
+            print(f"  \u2139 Rule {slug!r} has no auto-testable path_globs (contains '?' or '[abc]' \u2014 manual verification required)")
+
+    return ok
+
+
+def _doctor_check_activation(vault: Path) -> bool:
+    """Four activation-related doctor checks:
+
+    1. Malformed activate/enforce blocks in feedback files.
+    2. Stale activation index (index mtime older than newest feedback file mtime).
+    3. Suspicious deny_pattern (< 5 chars, or matches "echo hello").
+    4. Overly-broad activates_on.path_globs (**/* or *).
+
+    Each check is fail-safe: a bad file is skipped, not a crash.
+    Returns True if no warnings were emitted.
+    """
+    import re as _re
+    from mnemo.core.filters import parse_frontmatter
+    from mnemo.core.rule_activation import parse_block
+
+    feedback_dir = vault / "shared" / "feedback"
+    ok = True
+
+    if not feedback_dir.is_dir():
+        return True
+
+    candidates = sorted(feedback_dir.glob("*.md"))
+    newest_mtime: float = 0.0
+    for md_path in candidates:
+        try:
+            mtime = md_path.stat().st_mtime
+            if mtime > newest_mtime:
+                newest_mtime = mtime
+        except OSError:
+            pass
+
+    # --- Check 1: malformed blocks ---
+    # --- Check 3: suspicious deny_pattern ---
+    # --- Check 4: overly-broad path_globs ---
+    _BENIGN_TEST_INPUT = "echo hello"
+    _BROAD_GLOBS = {"**/*", "*"}
+
+    for md_path in candidates:
+        try:
+            text = md_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue  # skip unreadable files
+
+        try:
+            fm = parse_frontmatter(text)
+        except Exception:
+            continue
+
+        rel = md_path.name
+
+        # --- Check 1: enforce block present-but-invalid ---
+        if fm.get("enforce") is not None:
+            parsed, err = parse_block("enforce", fm)
+            if parsed is None:
+                print(f"  \u26a0 Malformed enforce block in {rel}: {err}")
+                print(f"       \u2192 fix the frontmatter in shared/feedback/{rel}")
+                ok = False
+            else:
+                # --- Check 3: suspicious deny_pattern ---
+                for pattern in parsed.get("deny_patterns", []):
+                    suspicious = False
+                    reason = ""
+                    if len(pattern) < 5:
+                        suspicious = True
+                        reason = f"pattern {pattern!r} is shorter than 5 characters"
+                    elif _re.search(pattern, _BENIGN_TEST_INPUT, _re.IGNORECASE | _re.DOTALL):
+                        suspicious = True
+                        reason = f"pattern {pattern!r} matches benign input {_BENIGN_TEST_INPUT!r} — too permissive"
+                    if suspicious:
+                        print(f"  \u26a0 Suspicious deny_pattern in {rel}: {reason}")
+                        print(f"       \u2192 tighten the pattern so it doesn't match safe commands")
+                        ok = False
+
+        # --- Check 1: activates_on block present-but-invalid ---
+        if fm.get("activates_on") is not None:
+            parsed_enrich, err = parse_block("activates_on", fm)
+            if parsed_enrich is None:
+                print(f"  \u26a0 Malformed activates_on block in {rel}: {err}")
+                print(f"       \u2192 fix the frontmatter in shared/feedback/{rel}")
+                ok = False
+            else:
+                # --- Check 4: overly-broad path_globs ---
+                for glob in parsed_enrich.get("path_globs", []):
+                    if glob in _BROAD_GLOBS:
+                        print(f"  \u26a0 Overly-broad path_glob {glob!r} in {rel}: matches virtually every file")
+                        print(f"       \u2192 narrow the glob (e.g. **/*.py, src/**/*.ts) to avoid false positives")
+                        ok = False
+
+    # --- Check 2: stale activation index ---
+    index_path = vault / ".mnemo" / "rule-activation-index.json"
+    if index_path.exists() and newest_mtime > 0:
+        try:
+            index_mtime = index_path.stat().st_mtime
+            if index_mtime < newest_mtime:
+                import datetime as _dt
+                def _fmt(ts: float) -> str:
+                    return _dt.datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S")
+                print(f"  \u26a0 Activation index is stale (newest feedback file: {_fmt(newest_mtime)}, index: {_fmt(index_mtime)}). Run 'mnemo extract' to rebuild.")
+                ok = False
+        except OSError:
+            pass
+
+    return ok