memgit 0.13.0__tar.gz → 0.14.0__tar.gz

{memgit-0.13.0 → memgit-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgit
-Version: 0.13.0
+Version: 0.14.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
@@ -22,14 +22,14 @@ License-File: LICENSE
 Requires-Dist: click>=8.0
 Requires-Dist: rich>=13.0
 Requires-Dist: mcp<2,>=1.28.1
+Requires-Dist: pynacl>=1.5
+Requires-Dist: httpx>=0.27
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-anyio>=0.0.0; extra == "dev"
 Provides-Extra: tokens
 Requires-Dist: tiktoken>=0.7; extra == "tokens"
 Provides-Extra: cloud
-Requires-Dist: pynacl>=1.5; extra == "cloud"
-Requires-Dist: httpx>=0.27; extra == "cloud"
 Dynamic: license-file
 
 <p align="center">
@@ -160,7 +160,7 @@ pip install memgit
 ```
 (The Chocolatey package is live on community.chocolatey.org; newly pushed versions can take a few days to clear moderation — `pip install memgit` always has the latest.)
 
-**Any AI tool config (no Python needed — npx auto-installs on first run):**
+**Any AI tool config (needs Python 3.11+ on PATH; npx installs memgit into its own environment on first run and creates the store):**
 ```json
 { "mcpServers": { "memgit": { "command": "npx", "args": ["-y", "memgit-mcp"] } } }
 ```
@@ -216,15 +216,16 @@ memgit resume --json     # for tooling
 Wire it into Claude Code so memory becomes **automatic** — no tool call, no judgment required:
 
 ```bash
-memgit setup hooks       # installs all five hooks (~/.claude/settings.json)
+memgit setup hooks       # installs all six hooks (~/.claude/settings.json)
 ```
 
 | Hook | What it enforces |
 |---|---|
 | `SessionStart` | every session opens with the resume digest in context — status board, checkpoints, critical rules, memory index |
 | `UserPromptSubmit` | each prompt is BM25-matched against the store; relevant memories are injected, ending with a "+N more on '<topic>'" depth hint when more exists (silent when nothing clears the relevance bar; never repeats within a session) — `--no-recall` to skip |
+| `PreToolUse` | a Bash or file-write call that matches a memory's triggers is refused with the rule as the reason (priority-3 feedback and conventions) or gets the rule as context (the rest). memgit allow SLUG opens a short override window. Trigger cache only, `--no-gate` to skip |
 | `PostToolUse` | reading a file whose path matches a memory tag surfaces a one-line hint ("6 memories tagged 'x' relate to this path") — tagmap cache only, capped 3/session, `--no-ctx-recall` to skip |
-| `Stop` (guard) | a session that did real work but saved nothing gets ONE nudge to save durable facts before finishing — `--no-guard` to skip |
+| `Stop` (guard) | a governed call that went through without the gate, or a session that did real work but saved nothing, gets ONE block before finishing. `--no-guard` to skip |
 | `Stop` (sync) | markdown memories are checkpointed asynchronously at session end |
 
 Why hooks and not just good tool descriptions? We measured it: across 166 real sessions, hook-injected context was delivered in **100%** of them while voluntary memory-tool calls happened in **6%**. What a hook enforces happens.
@@ -325,6 +326,29 @@ memgit pro deactivate         # remove the key from this machine
   exports keep working.
 - If this store is logged in to memgit cloud, `pro activate` also upgrades that account.
 
+### Sync between machines and with a team
+
+```bash
+memgit cloud signup --email you@example.com   # 14-day trial; keys are made on this machine
+memgit cloud team create myteam
+memgit cloud link myteam/memory               # creates the cloud repo on first link
+memgit cloud auto on                          # every save syncs in the background from now on
+```
+
+With autosync on, each save (including every `save_memory` your AI makes) starts one
+background pull-then-push and returns immediately, and each session start pulls what other
+machines saved. `memgit cloud auto status` shows the last run and why it would not run.
+
+On a machine that runs an agent but no interactive sessions (a Mac mini, a VM), log in and
+link once, then keep it current under systemd or launchd:
+
+```bash
+memgit cloud watch --interval 60                       # pull and push forever, one JSON line per run
+memgit cloud watch --export ~/agent/.hermes.md         # also write the digest for agents that read context files
+```
+
+Everything leaves the machine end-to-end encrypted; the server stores ciphertext only.
+
 ---
 
 ## Backups that actually happen
@@ -445,7 +469,9 @@ memgit setup cline
 memgit setup continue
 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)
+                                  # action gate on Bash and file writes, compliance and
+                                  # capture guard + auto-sync at stop (--no-recall / --no-guard / --no-gate)
+memgit doctor --rules             # critical rules next to same-topic lines in CLAUDE.md, AGENTS.md, ...
 
 # Pro (licence key)
 memgit pro activate <key>         # Polar-issued key; unlocks hosted E2E sync
@@ -510,6 +536,9 @@ memgit talks to nothing.
 | Cloud sync | `MEMGIT_CLOUD_API` | Overrides the memgit cloud API base URL. |
 |  | `MEMGIT_CLOUD_APP` | Overrides the memgit cloud web app base URL used in printed links. |
 |  | `MEMGIT_CLOUD_NO_CACHE` | Set to 1/true/yes to keep decrypted keys out of credentials.json; the passphrase is then re-prompted per command. |
+|  | `MEMGIT_NO_AUTOSYNC` | Set to 1/true/yes to stop saves and session starts from syncing to memgit cloud in the background, for this process only. |
+|  | `MEMGIT_AUTOSYNC_MAX_AGE` | Seconds after which a read (search, recall, an MCP lookup) starts a background fetch from memgit cloud (default 300). 0 turns read-triggered fetching off; saves and session starts still sync. |
+|  | `MEMGIT_AUTOSYNC_WAIT` | Seconds a session start waits for the fetch from memgit cloud before rendering the digest (default 3). 0 never waits. |
 | Tuning | `MEMGIT_LOCK_TIMEOUT` | Seconds a writer waits for the store lock before giving up (default 10). |
 |  | `MEMGIT_IDLE_EVICT_SECONDS` | Idle seconds before the MCP server drops its in-memory caches while staying connected (default 900). |
 |  | `MEMGIT_HOUSEKEEPING_INTERVAL` | Seconds between the MCP server's housekeeping passes. |

{memgit-0.13.0 → memgit-0.14.0}/README.md

@@ -126,7 +126,7 @@ pip install memgit
 ```
 (The Chocolatey package is live on community.chocolatey.org; newly pushed versions can take a few days to clear moderation — `pip install memgit` always has the latest.)
 
-**Any AI tool config (no Python needed — npx auto-installs on first run):**
+**Any AI tool config (needs Python 3.11+ on PATH; npx installs memgit into its own environment on first run and creates the store):**
 ```json
 { "mcpServers": { "memgit": { "command": "npx", "args": ["-y", "memgit-mcp"] } } }
 ```
@@ -182,15 +182,16 @@ memgit resume --json     # for tooling
 Wire it into Claude Code so memory becomes **automatic** — no tool call, no judgment required:
 
 ```bash
-memgit setup hooks       # installs all five hooks (~/.claude/settings.json)
+memgit setup hooks       # installs all six hooks (~/.claude/settings.json)
 ```
 
 | Hook | What it enforces |
 |---|---|
 | `SessionStart` | every session opens with the resume digest in context — status board, checkpoints, critical rules, memory index |
 | `UserPromptSubmit` | each prompt is BM25-matched against the store; relevant memories are injected, ending with a "+N more on '<topic>'" depth hint when more exists (silent when nothing clears the relevance bar; never repeats within a session) — `--no-recall` to skip |
+| `PreToolUse` | a Bash or file-write call that matches a memory's triggers is refused with the rule as the reason (priority-3 feedback and conventions) or gets the rule as context (the rest). memgit allow SLUG opens a short override window. Trigger cache only, `--no-gate` to skip |
 | `PostToolUse` | reading a file whose path matches a memory tag surfaces a one-line hint ("6 memories tagged 'x' relate to this path") — tagmap cache only, capped 3/session, `--no-ctx-recall` to skip |
-| `Stop` (guard) | a session that did real work but saved nothing gets ONE nudge to save durable facts before finishing — `--no-guard` to skip |
+| `Stop` (guard) | a governed call that went through without the gate, or a session that did real work but saved nothing, gets ONE block before finishing. `--no-guard` to skip |
 | `Stop` (sync) | markdown memories are checkpointed asynchronously at session end |
 
 Why hooks and not just good tool descriptions? We measured it: across 166 real sessions, hook-injected context was delivered in **100%** of them while voluntary memory-tool calls happened in **6%**. What a hook enforces happens.
@@ -291,6 +292,29 @@ memgit pro deactivate         # remove the key from this machine
   exports keep working.
 - If this store is logged in to memgit cloud, `pro activate` also upgrades that account.
 
+### Sync between machines and with a team
+
+```bash
+memgit cloud signup --email you@example.com   # 14-day trial; keys are made on this machine
+memgit cloud team create myteam
+memgit cloud link myteam/memory               # creates the cloud repo on first link
+memgit cloud auto on                          # every save syncs in the background from now on
+```
+
+With autosync on, each save (including every `save_memory` your AI makes) starts one
+background pull-then-push and returns immediately, and each session start pulls what other
+machines saved. `memgit cloud auto status` shows the last run and why it would not run.
+
+On a machine that runs an agent but no interactive sessions (a Mac mini, a VM), log in and
+link once, then keep it current under systemd or launchd:
+
+```bash
+memgit cloud watch --interval 60                       # pull and push forever, one JSON line per run
+memgit cloud watch --export ~/agent/.hermes.md         # also write the digest for agents that read context files
+```
+
+Everything leaves the machine end-to-end encrypted; the server stores ciphertext only.
+
 ---
 
 ## Backups that actually happen
@@ -411,7 +435,9 @@ memgit setup cline
 memgit setup continue
 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)
+                                  # action gate on Bash and file writes, compliance and
+                                  # capture guard + auto-sync at stop (--no-recall / --no-guard / --no-gate)
+memgit doctor --rules             # critical rules next to same-topic lines in CLAUDE.md, AGENTS.md, ...
 
 # Pro (licence key)
 memgit pro activate <key>         # Polar-issued key; unlocks hosted E2E sync
@@ -476,6 +502,9 @@ memgit talks to nothing.
 | Cloud sync | `MEMGIT_CLOUD_API` | Overrides the memgit cloud API base URL. |
 |  | `MEMGIT_CLOUD_APP` | Overrides the memgit cloud web app base URL used in printed links. |
 |  | `MEMGIT_CLOUD_NO_CACHE` | Set to 1/true/yes to keep decrypted keys out of credentials.json; the passphrase is then re-prompted per command. |
+|  | `MEMGIT_NO_AUTOSYNC` | Set to 1/true/yes to stop saves and session starts from syncing to memgit cloud in the background, for this process only. |
+|  | `MEMGIT_AUTOSYNC_MAX_AGE` | Seconds after which a read (search, recall, an MCP lookup) starts a background fetch from memgit cloud (default 300). 0 turns read-triggered fetching off; saves and session starts still sync. |
+|  | `MEMGIT_AUTOSYNC_WAIT` | Seconds a session start waits for the fetch from memgit cloud before rendering the digest (default 3). 0 never waits. |
 | Tuning | `MEMGIT_LOCK_TIMEOUT` | Seconds a writer waits for the store lock before giving up (default 10). |
 |  | `MEMGIT_IDLE_EVICT_SECONDS` | Idle seconds before the MCP server drops its in-memory caches while staying connected (default 900). |
 |  | `MEMGIT_HOUSEKEEPING_INTERVAL` | Seconds between the MCP server's housekeeping passes. |

{memgit-0.13.0 → memgit-0.14.0}/memgit/__init__.py

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

{memgit-0.13.0 → memgit-0.14.0}/memgit/cli.py

@@ -657,6 +657,15 @@ def resume(checkpoints, recent, plain, fmt_json, project):
     import json as _j
     from .project import detect_project
     repo = _require_repo()
+    # Session start is when another machine's memories should arrive. The pull
+    # runs detached and the digest waits a bounded moment for it (3 s unless
+    # MEMGIT_AUTOSYNC_WAIT says otherwise), so a quick network puts them in
+    # this digest and a slow one never holds it up.
+    try:
+        from .cloud.auto import fetch_for_session
+        fetch_for_session(repo.path)
+    except Exception:
+        pass
     if project is None:
         project = detect_project()
     ctx = repo.resume_context(checkpoints=checkpoints, recent=recent, project=project)
@@ -743,9 +752,15 @@ def resume(checkpoints, recent, plain, fmt_json, project):
     console.print()
 
 
-#: Hard character budget for the injected resume digest (~2.4k tokens). Paid
-#: at the start of EVERY session — past this, sections trim in a fixed order.
-RESUME_BUDGET_CHARS = 9_500
+#: Size at which Claude Code stops inlining hook output: above it the digest
+#: is saved to a file and the model sees a ~2 KB preview, so everything past
+#: the preview (status board, critical rules, index) never reaches context.
+#: Measured 2026-10-23: an 11,297-character digest was persisted, not inlined.
+HOST_INLINE_LIMIT_CHARS = 10_000
+#: Hard budget for the injected resume digest, with headroom under the host
+#: limit. Measured in UTF-16 code units, the way a JavaScript host counts
+#: string length (an emoji is two). Paid at the start of EVERY session.
+RESUME_BUDGET_CHARS = 9_000
 
 #: A status-board tracker not re-saved in this many days is flagged as possibly
 #: stale — trackers are only as fresh as their last write, so an old one may
@@ -759,33 +774,82 @@ def _tracker_age_days(ts) -> int:
     return max(0, (now - ts).days)
 
 
-def _format_resume_plain(ctx: dict) -> str:
+def _host_len(text: str) -> int:
+    """Length as a JavaScript host counts it (UTF-16 code units)."""
+    return len(text.encode('utf-16-le')) // 2
+
+
+def _strip_auto_block(body: str) -> str:
+    """A core-guide body without its usage-ranked pointer block."""
+    from .delivery import AUTO_START, AUTO_END
+    if AUTO_START not in body:
+        return body
+    head, _, rest = body.partition(AUTO_START)
+    _, _, tail = rest.partition(AUTO_END)
+    return (head.rstrip() + '\n(auto pointers cut to fit the session-start '
+            'budget — memgit core show has them)\n' + tail.lstrip()).rstrip()
+
+
+def _format_resume_plain(ctx: dict, budget: int = None) -> str:
     """Plain-text resume digest — injected into AI context by the SessionStart
-    hook, under a hard budget of RESUME_BUDGET_CHARS.
-
-    When the render exceeds the budget, sections are trimmed in a fixed
-    order — recent memories 10→5, checkpoints 5→3, critical-rule text
-    clipped to 160 chars, memory-index topics 8→5, recent 5→3 — re-rendering
-    after each cut until it fits. The core operating guide body and the
-    status board are NEVER trimmed: they are the two surfaces the model must
-    be able to trust in full.
+    hook, never longer than RESUME_BUDGET_CHARS.
+
+    The budget is a guarantee, not a target: a digest over the host's inline
+    limit is saved to a file and almost none of it is read, which is worse
+    than any trim. Sections trim in a fixed order, re-rendering after each
+    cut: recent memories, checkpoints, index and rule text first; then the
+    status board and critical list shrink; then the core guide loses its
+    auto-pointer block; and only as a last resort is the core guide body cut,
+    with a pointer to the full text.
     """
+    budget = budget or RESUME_BUDGET_CHARS
     text = _render_resume_plain(ctx)
-    if len(text) <= RESUME_BUDGET_CHARS:
+    if _host_len(text) <= budget:
         return text
     ctx = dict(ctx)  # never mutate the caller's context
+
+    def _core_no_auto(c):
+        c['core_memories'] = [dict(m, body=_strip_auto_block(m.get('body') or ''))
+                              for m in c.get('core_memories') or []]
+
     trims = (
         lambda c: c.update(recent_memories=c.get('recent_memories', [])[:5]),
         lambda c: c.update(checkpoints=c.get('checkpoints', [])[:3]),
         lambda c: c.update(_crit_clip=160),
         lambda c: c.update(entity_index=c.get('entity_index', [])[:5]),
         lambda c: c.update(recent_memories=c.get('recent_memories', [])[:3]),
+        lambda c: c.update(_tracker_clip=100, _crit_clip=130),
+        lambda c: c.update(_crit_max=12),
+        _core_no_auto,
+        lambda c: c.update(tracker_memories=c.get('tracker_memories', [])[:5],
+                           recent_memories=[], checkpoints=c.get('checkpoints', [])[:1]),
+        lambda c: c.update(_crit_max=8, _crit_clip=110, entity_index=[]),
     )
     for trim in trims:
         trim(ctx)
         text = _render_resume_plain(ctx)
-        if len(text) <= RESUME_BUDGET_CHARS:
-            break
+        if _host_len(text) <= budget:
+            return text
+
+    # Last resort: cut the core guide body to what is left, with a pointer.
+    over = _host_len(text) - budget
+    cores = ctx.get('core_memories') or []
+    if cores and not ctx.get('core_delivered'):
+        note = '\n…(core guide cut to fit; full text: memgit core show)'
+        total = sum(len(m.get('body') or '') for m in cores)
+        keep = max(0, total - over - len(note) * len(cores) - 50)
+        cut = []
+        for m in cores:
+            body = m.get('body') or ''
+            share = int(keep * len(body) / total) if total else 0
+            cut.append(dict(m, body=(body[:share].rstrip() + note) if share < len(body) else body))
+        ctx['core_memories'] = cut
+        text = _render_resume_plain(ctx)
+    if _host_len(text) > budget:
+        tail = '\n…(digest cut at the session-start budget)'
+        while _host_len(text) + _host_len(tail) > budget and text:
+            text = text[:max(0, len(text) - (_host_len(text) + _host_len(tail) - budget) - 1)]
+        text += tail
     return text
 
 
@@ -800,6 +864,8 @@ def _render_resume_plain(ctx: dict) -> str:
         return text if len(text) <= n else text[:n - 1] + '…'
 
     crit_clip = int(ctx.get('_crit_clip', 200))
+    crit_max = int(ctx.get('_crit_max', 20))
+    tracker_clip = int(ctx.get('_tracker_clip', 160))
 
     proj = f' · project {ctx["project"]}' if ctx.get('project') else ''
     lines = [
@@ -827,7 +893,20 @@ def _render_resume_plain(ctx: dict) -> str:
                 body = (m.get('body') or m['rule']).rstrip()
                 lines.append('')
                 lines.append(body)
-    # Status board: live entity state. Rendered right after the guide because
+    # Critical rules right after the guide, before the status board: a host
+    # that previews only the head of the digest must still see the rules,
+    # ranked (see Repository.resume_context) so the cut keeps the ones most
+    # likely to be broken.
+    if ctx.get('critical_memories'):
+        lines.append('')
+        lines.append('## Critical rules — always apply')
+        crit = ctx['critical_memories']
+        for m in crit[:crit_max]:
+            lines.append(f'- {m["slug"]}: {clip(m["rule"], crit_clip)}')
+        if len(crit) > crit_max:
+            lines.append(f'- …and {len(crit) - crit_max} more — run list_memories '
+                         'with min_priority=3')
+    # Status board: live entity state. Rendered right after the rules because
     # orientation ("what is the CURRENT state of things") is worth more than
     # history. The freshness stamp is what tells the model to trust or
     # re-verify a line.
@@ -840,7 +919,7 @@ def _render_resume_plain(ctx: dict) -> str:
             stamp = m['timestamp'].strftime('%m-%d')
             age = _tracker_age_days(m['timestamp'])
             stale = f' ⚠ {age}d old' if age >= STATUS_STALE_DAYS else ''
-            lines.append(f'- {m["slug"]} (upd {stamp}{stale}): {clip(m["rule"], 160)}')
+            lines.append(f'- {m["slug"]} (upd {stamp}{stale}): {clip(m["rule"], tracker_clip)}')
         lines.append('(State changed? Update the tracker: save_memory with the '
                      'same slug. ⚠ = not updated recently, may lag the files.)')
     st = ctx['staged']
@@ -869,14 +948,6 @@ def _render_resume_plain(ctx: dict) -> str:
                      if m.get('project') and m['project'] != ctx.get('project') else '')
             unv = ' ⚠unverified' if m.get('unverified') else ''
             lines.append(f'- {m["slug"]} ({m["type"]}, {ts}){other}{unv}: {clip(m["rule"], 160)}')
-    if ctx['critical_memories']:
-        lines.append('')
-        lines.append('## Critical rules — always apply')
-        crit = ctx['critical_memories']
-        for m in crit[:20]:
-            lines.append(f'- {m["slug"]}: {clip(m["rule"], crit_clip)}')
-        if len(crit) > 20:
-            lines.append(f'- …and {len(crit) - 20} more — run list_memories with min_priority=3')
     if ctx.get('maintenance'):
         lines.append('')
         lines.append(f'## Maintenance needed\n- {ctx["maintenance"]}')
@@ -940,6 +1011,34 @@ def hook_stop_guard():
     sys.exit(stop_guard())
 
 
+@hook.command('action-gate')
+def hook_action_gate():
+    """PreToolUse: refuse or annotate calls governed by a rule's triggers (stdin JSON)."""
+    from .hooks import action_gate
+    sys.exit(action_gate())
+
+
+@cli.command('allow')
+@click.argument('slug')
+@click.option('--minutes', '-m', default=15, show_default=True,
+              help='How long the override lasts (max 120)')
+def allow_cmd(slug, minutes):
+    """Let calls governed by SLUG's triggers through for a short window.
+
+    For when the user has explicitly asked for an action a saved rule would
+    refuse. The override is logged, and the session's Stop check counts it as
+    a decision rather than a violation.
+    """
+    from .gate import allow
+    repo = _require_repo()
+    if repo.get(slug) is None:
+        err.print(f'[red]no memory with slug {slug!r}[/red]')
+        sys.exit(1)
+    until = allow(repo, slug, minutes)
+    console.print(f'[yellow]allowed[/yellow] calls governed by [cyan]{slug}[/cyan] '
+                  f'until {until.strftime("%H:%M:%S")} UTC')
+
+
 @hook.command('context-recall')
 def hook_context_recall():
     """PostToolUse: hint when memories exist about the file being read (stdin JSON)."""
@@ -2507,8 +2606,13 @@ def gc(dry_run, squash_keep, reflog_keep, fmt_json):
               help='With --repair-markup: only this project')
 @click.option('--yes', 'confirm', is_flag=True,
               help='With --repair-markup: write the repair as one checkpoint')
+@click.option('--rules', 'check_rules', is_flag=True,
+              help="Compare this project's critical rules with the rule files "
+                   'its hosts load (CLAUDE.md, AGENTS.md, ...) and list '
+                   'same-topic passages to check for contradictions')
 def doctor(relabel_path, prune_slugs, clean_caches, prune_sessions,
-           full_audit, fmt_json, repair_markup, repair_project, confirm):
+           full_audit, fmt_json, repair_markup, repair_project, confirm,
+           check_rules):
     """Diagnose and repair store hygiene: provenance, usage ledger, caches.
 
     With no options, prints a report: quarantined (`_unknown`) and
@@ -2595,6 +2699,10 @@ def doctor(relabel_path, prune_slugs, clean_caches, prune_sessions,
         acted = True
         _repair_markup(repo, repair_project, confirm)
 
+    if check_rules:
+        acted = True
+        _doctor_rules(repo, fmt_json)
+
     if acted:
         return
 
@@ -2656,6 +2764,31 @@ def doctor(relabel_path, prune_slugs, clean_caches, prune_sessions,
     else:
         console.print('no memory carries tool-call markup in its fields')
 
+    # Critical behaviour rules with no trigger are enforced only by recall —
+    # the backlog the action gate cannot cover until each gets one.
+    from .gate import needs_trigger
+    from .links import filter_active
+    from .project import detect_project, project_affinity
+    here = detect_project()
+    untrig = [m for m in filter_active(mnemonics)
+              if needs_trigger(m.type_code, m.priority) and not m.triggers
+              and not m.unverified]
+    trig = [m for m in filter_active(mnemonics) if m.triggers]
+    if untrig:
+        mine = [m for m in untrig
+                if here and m.project and project_affinity(m.project, here) >= 1]
+        console.print(f'[yellow]{len(untrig)} critical behaviour rules (p3 fb/cn) '
+                      f'have no triggers[/yellow] — the action gate cannot '
+                      f'enforce them; {len(trig)} memories carry triggers')
+        for m in sorted(mine, key=lambda m: m.timestamp, reverse=True)[:10]:
+            console.print(f'  [dim]{m.slug}[/dim]')
+        if mine:
+            console.print(f'  [dim]({len(mine)} in {here}; add triggers with '
+                          f'save_memory triggers=[...])[/dim]')
+    else:
+        console.print(f'every critical behaviour rule carries triggers '
+                      f'({len(trig)} memories with triggers)')
+
     from .audit import audit as _audit
     rep = _audit(repo)
     _render_scope_losses(rep, full_audit)
@@ -2663,6 +2796,45 @@ def doctor(relabel_path, prune_slugs, clean_caches, prune_sessions,
         console.print_json(data=rep)
 
 
+def _doctor_rules(repo, fmt_json: bool = False) -> None:
+    """Report same-topic pairs between critical rules and host rule files."""
+    import json as _j
+    from .drift import find_drift, rule_files
+    from .project import detect_project
+    project = detect_project()
+    files = rule_files(Path.cwd())
+    pairs = find_drift(repo.list(), files, project) if project else []
+    if fmt_json:
+        print(_j.dumps({
+            'project': project,
+            'files': [str(f) for f in files],
+            'pairs': [{'slug': d.slug, 'rule': d.rule, 'file': str(d.passage.path),
+                       'line': d.passage.line, 'passage': d.passage.text,
+                       'score': d.score} for d in pairs],
+        }, indent=2))
+        return
+    console.print(f'[bold]memgit doctor --rules[/bold] — project {project or "(none)"}, '
+                  f'{len(files)} rule file(s)')
+    for f in files:
+        console.print(f'  [dim]{f}[/dim]')
+    if not project:
+        console.print('[yellow]no project detected here — run from the project '
+                      'directory[/yellow]')
+        return
+    if not pairs:
+        console.print('no rule-file passage shares a topic with a critical rule')
+        return
+    console.print(f'{len(pairs)} same-topic pair(s). Each needs a reader: if the '
+                  'file says the opposite of the rule, change the file or '
+                  'supersede the rule, so the two stop disagreeing.\n')
+    for d in pairs:
+        rule = d.rule if len(d.rule) <= 200 else d.rule[:199] + '…'
+        text = d.passage.text if len(d.passage.text) <= 240 else d.passage.text[:239] + '…'
+        console.print(f'[cyan]{d.slug}[/cyan] [dim](score {d.score})[/dim]')
+        console.print(f'  rule: {rule}')
+        console.print(f'  {d.passage.path}:{d.passage.line}: {text}\n')
+
+
 def _repair_markup(repo, project, confirm) -> None:
     """Split damaged memories back into their fields; dry run without confirm.
 
@@ -3480,7 +3652,7 @@ def setup_antigravity(dry_run):
 
 #: substrings identifying a hook command as one of ours (any generation)
 _MEMGIT_HOOK_SIGNS = ('resume --plain', 'hook prompt-recall', 'hook stop-guard',
-                      'hook context-recall', ' sync')
+                      'hook context-recall', 'hook action-gate', ' sync')
 
 
 def _is_memgit_hook_entry(h: dict) -> bool:
@@ -3499,11 +3671,13 @@ def _is_memgit_hook_entry(h: dict) -> bool:
               help='Skip the end-of-session capture guard (Stop)')
 @click.option('--no-ctx-recall', is_flag=True,
               help='Skip the context-recall hook (PostToolUse on Read/Grep/Glob)')
+@click.option('--no-gate', is_flag=True,
+              help='Skip the action gate (PreToolUse on Bash and file writes)')
 @click.option('--dry-run', is_flag=True, help='Show the change without writing')
-def setup_hooks(remove, no_recall, no_guard, no_ctx_recall, dry_run):
+def setup_hooks(remove, no_recall, no_guard, no_ctx_recall, no_gate, dry_run):
     """Install the Claude Code hooks that make memory automatic.
 
-    Five hooks, one principle: what a hook enforces happens, what a tool
+    Six hooks, one principle: what a hook enforces happens, what a tool
     description suggests mostly doesn't (measured: 6% voluntary engagement
     vs 100% hook delivery).
 
@@ -3513,13 +3687,16 @@ def setup_hooks(remove, no_recall, no_guard, no_ctx_recall, dry_run):
                         memory index
       UserPromptSubmit  inject memories relevant to each prompt (BM25,
                         silent when nothing clears the relevance bar)
+      PreToolUse        action gate — a Bash or file-write call matching a
+                        memory's triggers is refused (critical rules) or
+                        annotated (the rest); trigger cache only
       PostToolUse       context recall — reading a file whose path matches
                         a memory tag surfaces a one-line depth hint
                         (tagmap cache only, capped 3/session)
-      Stop              capture guard — a substantive session ending with
-                        zero memory writes gets ONE nudge to save durable
-                        facts; plus async `memgit sync` to checkpoint
-                        markdown memories
+      Stop              compliance replay + capture guard — a governed call
+                        that went through, or a substantive session ending
+                        with zero memory writes, gets ONE block; plus async
+                        `memgit sync` to checkpoint markdown memories
 
     Hooks live in ~/.claude/settings.json (unlike MCP servers, which live
     in ~/.claude.json).
@@ -3550,6 +3727,10 @@ def setup_hooks(remove, no_recall, no_guard, no_ctx_recall, dry_run):
             {'type': 'command',
              'command': f'{base} hook prompt-recall 2>/dev/null || true'},
         ],
+        'PreToolUse': [] if no_gate else [
+            {'type': 'command',
+             'command': f'{base} hook action-gate 2>/dev/null || true'},
+        ],
         'PostToolUse': [] if no_ctx_recall else [
             {'type': 'command',
              'command': f'{base} hook context-recall 2>/dev/null || true'},
@@ -3569,10 +3750,11 @@ def setup_hooks(remove, no_recall, no_guard, no_ctx_recall, dry_run):
     }
     #: PostToolUse fires per tool call — matcher limits it to the file-reading
     #: tools so the hook binary isn't spawned on every Bash/Edit.
-    _MATCHERS = {'PostToolUse': 'Read|Grep|Glob'}
+    from .gate import GATE_MATCHER
+    _MATCHERS = {'PreToolUse': GATE_MATCHER, 'PostToolUse': 'Read|Grep|Glob'}
 
     changed = []
-    for event in ('SessionStart', 'UserPromptSubmit', 'PostToolUse', 'Stop'):
+    for event in ('SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop'):
         entries = hooks.setdefault(event, [])
         had = [h for h in entries if isinstance(h, dict) and _is_memgit_hook_entry(h)]
         entries[:] = [h for h in entries if h not in had]
@@ -3600,7 +3782,9 @@ def setup_hooks(remove, no_recall, no_guard, no_ctx_recall, dry_run):
             tag = ' [dim](async)[/dim]' if inner.get('async') else ''
             console.print(f'  [cyan]{event}[/cyan]  [dim]{inner["command"]}[/dim]{tag}')
     console.print('[dim]Resume at session start, relevant memories per prompt, '
-                  'context hints on file reads, capture guard + sync at stop.[/dim]')
+                  'rule triggers checked before Bash and file writes, '
+                  'context hints on file reads, compliance + capture guard + '
+                  'sync at stop.[/dim]')
 
 
 @setup.command('print-config')
@@ -3758,8 +3942,8 @@ except Exception:
     # extras missing or broken — plain memgit must keep working untouched
     @cli.group()
     def cloud():
-        """E2E-encrypted team sync — requires: pip install 'memgit[cloud]'"""
+        """E2E-encrypted team sync — its dependencies failed to import; reinstall memgit."""
 
     @cloud.command('setup', help="Show how to enable cloud sync.")
     def _cloud_setup_hint():
-        console.print(r"Install the cloud extra first:  [bold]pip install 'memgit\[cloud]'[/bold]")
+        console.print("Cloud sync could not load pynacl or httpx. Reinstall:  [bold]pip install --upgrade --force-reinstall memgit[/bold]")

memgit-0.14.0/memgit/cloud/__init__.py

@@ -0,0 +1,7 @@
+"""memgit cloud — E2E-encrypted team sync (app.memgit.dev).
+
+Nothing here runs until a store is logged in and linked. The rest of memgit
+imports only `auto`, lazily, to start a background sync after a commit, at
+session start, and from a read when the last sync is old. pynacl and httpx are
+ordinary dependencies of the package.
+"""