memgit 0.6.2__tar.gz → 0.8.0__tar.gz

{memgit-0.6.2 → memgit-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgit
-Version: 0.6.2
+Version: 0.8.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
@@ -44,7 +44,7 @@ Version-controlled, cross-AI context that persists, diffs, rolls back, and syncs
 
 [![PyPI](https://img.shields.io/pypi/v/memgit)](https://pypi.org/project/memgit/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-245%20passing-brightgreen)](tests/)
+[![Tests](https://img.shields.io/badge/tests-404%20passing-brightgreen)](tests/)
 
 ---
 
@@ -68,9 +68,9 @@ You've probably already tried both. Here's why they hit a ceiling:
 
 ---
 
-## Proof — token savings you can measure
+## Proof — context costs you can measure
 
-Run this on your own store to see the actual numbers:
+Run this on your own store to see the actual numbers (measured where possible; estimates labeled):
 
 ```
 $ memgit stats
@@ -78,20 +78,17 @@ $ memgit stats
   Total memories:   108   (41 feedback · 23 user · 19 project · 12 reference · 8 convention · 5 lesson)
   Priority:          3 critical · 67 medium · 38 low
 
-  Token cost comparison:
-  ┌─────────────────────────────────────┬──────────────────┬───────────────────┬─────────────────────┐
-  │ Approach                            │ Tokens/session   │ vs full load      │ $/session (GPT-4o)  │
-  ├─────────────────────────────────────┼──────────────────┼───────────────────┼─────────────────────┤
-  │ claude.md / dump all memories       │ 12,840           │ 100%  baseline    │ $0.0321             │
-  │ memgit search (BM25 top-8)          │ 640              │ 5%  (95% savings) │ $0.0016             │
-  └─────────────────────────────────────┴──────────────────┴───────────────────┴─────────────────────┘
-
-  Weekly savings (10 sessions/week):
-    Tokens saved:   122,000/week
-    Cost saved:     $0.31/week  →  $15.86/year  (at GPT-4o input pricing, $2.50/M)
+  Context footprint  (measured where possible; estimates labeled)
+
+  Surface                                             Tokens
+  Full store (every memory as context)                12,840
+  Resume digest  (measured render)                       540
+  Recall block  (estimate: top-3 rules ≈ chars/4)        ~60
+
+  per-session injected ≈ 600 tokens (estimate) vs 12,840 tokens if the full store were loaded
 ```
 
-**Why such a big difference?** claude.md loads *all* context every session. memgit uses BM25 relevance scoring — it loads *only the 8 memories most relevant to the current session*, not everything you've ever recorded.
+**Why such a big difference?** claude.md loads *all* context every session. memgit injects a bounded resume digest plus BM25-matched recall — *only what is relevant to this session*, not everything you've ever recorded. The digest is measured by actually rendering it, and the store total is the real corpus size; nothing here is a simulated benchmark.
 
 ---
 
@@ -155,9 +152,11 @@ brew tap code4161/tap && brew install memgit
 
 **Windows:**
 ```powershell
+choco install memgit
+# or
 pip install memgit
 ```
-(`choco install memgit` is not live yet — the Chocolatey package is not on community.chocolatey.org. Use pip until it lands.)
+(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):**
 ```json
@@ -198,7 +197,7 @@ memgit onboard          # mines the repo, prints the bootstrap brief
 
 `onboard` first extracts a **repo digest** deterministically — git history (recent commit subjects, hot files/directories by churn, authors, branch, tags), detected stack from manifests, and the docs worth reading — using bounded, read-only probes that stay near-instant even on huge repositories. The brief then tells your AI agent exactly what to do with it: read only the listed files (no tree crawling), extract 10–20 durable facts (purpose, architecture, conventions, current state, gotchas), save each as a typed memory, and checkpoint the seed set. Paste it into a session — or don't: if the AI searches memory in a project that has none, the MCP server itself replies with the bootstrap instructions instead of a bare "no results."
 
-Memories are **project-scoped**: each carries the workspace it belongs to, searches boost the project you're standing in (global rules still surface), and the resume digest leads with *your current project's* recent work — not whatever repo you touched last night.
+Memories are **project-scoped, filter-by-default** (v0.7.0): each carries the workspace it belongs to, and searches, recall injections, and the resume digest (recent memories, checkpoints, depth hints) are **filtered** to the current project's family plus explicitly-global memories — another project's content never leaks in. Widen deliberately with `memgit search --all-projects` / `all_projects: true` (every hit then carries its `project` label), or hard-filter one project with `--project`. A memory with no project is **explicitly global** (applies everywhere): save one with `memgit add --global` or `project: ""`. A save whose project *cannot be determined* is never silently global — it's quarantined under `_unknown` (visible in `list` as `[?project]`, flagged by `lint`, surfaced nowhere) until you relabel it with `memgit doctor --relabel`.
 
 ---
 
@@ -289,10 +288,25 @@ The tool descriptions teach the AI **judgment** — "does this request depend on
 
 A project's hardest onboarding problem isn't *what* it does — it's *how to work in it*: which skill to invoke, which command to run, which tool to reach for. That lives in a `CLAUDE.md` or a skills folder the AI host may or may not be configured to read. memgit carries it for you.
 
-`memgit core seed` distills a compact operating guide from the project's existing skills + rule files. `memgit core sync` writes it into **every AI host's own rules surface** as a dedicated, memgit-owned file — `.claude/rules/memgit.md`, `.cursor/rules/memgit.mdc`, `.windsurf/rules/memgit.md`, `.clinerules/`, `.roo/rules/`, `.continue/rules/`, `.gemini/`, and a marker-block in Codex's `AGENTS.md`. It's **additive only** — memgit never touches your own config or content — and injected at session start, so any tool knows how to work in the project even when its native setup is missing.
+`memgit core seed` distills a compact operating guide from the project's existing skills + rule files. `memgit core sync` writes it into **every AI host's own rules surface** as a dedicated, memgit-owned file — `.claude/rules/memgit.md`, `.cursor/rules/memgit.mdc`, `.windsurf/rules/memgit.md`, `.clinerules/`, `.roo/rules/`, `.continue/rules/` — and marker-delimited blocks in the shared `GEMINI.md` (Gemini CLI auto-loads only that file) and Codex's `AGENTS.md`. It's **additive only** — memgit never touches your own config or content — and injected at session start, so any tool knows how to work in the project even when its native setup is missing.
 
 And it **learns**: a sidecar usage ledger tracks which memories actually get recalled, and the most-used ones are auto-promoted as pointers into the guide over time (budget-capped, decaying, and always subordinate to the repo's own rules — it never restates or overrides them). Drifted? `memgit core heal` rebuilds it.
 
+Since 0.8.0 it also **starts itself**: a project's first guide is created automatically once it holds a handful of memories, so the loop no longer waits on someone remembering to run `core seed`. The guide leads with what the project actually holds — "this project has N saved memories covering *topics*" — because a stated count of real prior work is evidence a model can act on, where an abstract instruction to check memory is something it can weigh against its own confidence and skip.
+
+---
+
+## Ranking you can prove
+
+Retrieval quality used to be adjusted on intuition. `memgit eval` replaces that with a measurement, using two frozen sets mined from the store itself:
+
+- **recall** — real prompts and the memories memgit actually surfaced for them. Measures *stability*: did a change break what used to work?
+- **synthetic** — each memory queried by its own `why`, expecting itself back, with the slug's own words stripped out of the query. Measures *correctness*, independently of any past ranking. (The recall set alone is circular — its answers came from the ranking under test.)
+
+Both report hit@1, recall@3/5/10 and MRR against a pinned baseline. There is deliberately no single blended score, and no fabricated "tokens saved" number.
+
+It earns its keep immediately. Two changes built for 0.8.0 looked obviously right and were measured wrong: a recency multiplier (cut — real-prompt hit@1 −0.020, MRR −0.018) and destructive stemming, which fixed its motivating query while costing hit@1 −0.038 overall (rebuilt as an additive field, then +0.020/+0.041/+0.019). A BM25 normalisation bug introduced in the same release was caught the same way.
+
 ---
 
 ## Depth advertisement, trackers & supersession (v0.6.0)
@@ -313,14 +327,14 @@ Measured across 289 real sessions: injected recall reached ~59% of them, but onl
 # Core (git-like)
 memgit init                       # initialize store (auto-detects best path)
 memgit onboard                    # bootstrap brief for an existing codebase
-memgit add <slug> <rule>          # stage a memory (--body detail, --project scope, --supersedes old-slug)
+memgit add <slug> <rule>          # stage a memory (--body detail, --project scope, --global everywhere, --supersedes old-slug)
 memgit commit -m "message"        # checkpoint current state
 memgit log                        # history
 memgit diff [sha1] [sha2]         # what changed
 memgit show <slug>                # display a memory
 memgit remove <slug>              # remove from active index (history preserved)
 memgit status                     # staged changes
-memgit search <query>             # BM25 relevance search
+memgit search <query>             # BM25 search, scoped to this project + global (--all-projects to widen)
 memgit rollback <ref>             # restore state to a checkpoint (HEAD~N or SHA)
 memgit resume                     # where we left off — session-start digest
 memgit merge <thread>             # three-way merge a thread into the current one
@@ -331,12 +345,23 @@ memgit core seed                  # draft a guide from this project's skills + r
 memgit core sync                  # deliver it into each AI host's own rules file (additive)
 memgit core show / edit           # view / curate the guide
 memgit core heal                  # self-repair a guide that has drifted
+                                  # (a project's FIRST guide is created automatically
+                                  #  once it holds 5+ memories — no command needed)
+
+# Retrieval evaluation — prove a ranking change helped
+memgit eval mine                  # freeze a regression set from real recall events
+memgit eval mine --synthetic      # non-circular set: query each memory by its own `why`
+memgit eval run --set recall      # hit@1 / recall@3,5,10 / MRR vs the pinned baseline
+memgit eval run --baseline        # pin the current result as the comparison point
+memgit eval run --misses 10       # inspect the cases where nothing relevant surfaced
 
 # Scale & proof
 memgit squash                     # compress old history (archives what it collapses)
-memgit gc                         # reclaim disk: sweep unreachable objects
-memgit stats                      # token savings + disk usage
-memgit lint                       # validate all memories
+memgit gc                         # reclaim disk: sweep unreachable objects + stale session caches
+memgit stats                      # measured context costs + disk usage
+memgit doctor                     # hygiene report: quarantined/_unknown memories, stale caches, orphaned usage
+memgit doctor --relabel map.json  # bulk re-project memories ({"slug": "Label" | ""}); one checkpoint
+memgit lint                       # validate all memories (flags unknown provenance)
 memgit fsck                       # verify store integrity
 
 # Import / export
@@ -385,6 +410,9 @@ memgit thread list / switch / create
 | **Windsurf** | MCP stdio | `memgit setup windsurf` |
 | **Cline / Roo-Code** | MCP stdio | `memgit setup cline` |
 | **Continue.dev** | MCP stdio | `memgit setup continue` |
+| **Codex** | MCP stdio (TOML) | `memgit setup codex` |
+| **Antigravity** | MCP stdio | `memgit setup antigravity` |
+| **Gemini CLI** | MCP stdio | `memgit setup gemini-cli` |
 | **ChatGPT (Custom Actions)** | HTTP + OpenAPI | `memgit serve --http` → import `http://localhost:7474/openapi.json` |
 | **Gemini API** | HTTP function calling | `memgit serve --http` + `llm-tool-definitions.json` |
 | **Any MCP tool** | MCP stdio | Add `{"command": "memgit", "args": ["serve"]}` to config |
@@ -445,7 +473,7 @@ git clone https://github.com/code4161/memgit.git
 cd memgit
 python -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
-pytest    # 245 tests, all passing, < 5 seconds
+pytest    # 404 tests, all passing, < 5 seconds
 ```
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).
@@ -470,14 +498,19 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 - [x] `memgit gc` — space reclamation (mark-and-sweep, lossless squash archive)
 - [x] Multi-agent write safety — store lock, auto-merge commits, `memgit merge`
 - [x] PyPI + Homebrew (tap) + npm published (v0.1.5)
-- [ ] Chocolatey (not yet live on community.chocolatey.org)
+- [x] Chocolatey — live on community.chocolatey.org (`choco install memgit`)
 - [x] Interactive setup wizard (`memgit setup`)
 - [x] Smart `memgit init` (auto-detects tool, no path needed)
 - [x] Lossless memories — full `body` alongside the compact rule (v0.3.0)
 - [x] Project-scoped memories + `memgit onboard` mid-project bootstrap (v0.3.0)
 - [x] VS Code extension (v0.1.5, Marketplace: code416-memgit.memgit)
+- [x] Codex + Antigravity support — MCP registration + `AGENTS.md` core guide (v0.8.0)
+- [x] `memgit eval` — measured retrieval quality, real + non-circular sets (v0.8.0)
+- [x] Usage-aware ranking — the recall ledger feeds relevance, not just the guide (v0.8.0)
+- [x] Automatic core-guide bootstrap — the self-improving loop starts itself (v0.8.0)
 - [ ] JetBrains plugin (Phase 3)
-- [ ] Semantic search via embeddings (Phase 4)
+- [ ] Semantic search via embeddings — gated on `memgit eval` showing a real gain (Phase 4)
+- [ ] Public benchmark numbers (LongMemEval, LoCoMo) (Phase 4)
 - [x] memgit.dev website (live)
 - [ ] Memory compression / auto-summarization (Phase 5)
 - [ ] Team access control + audit trail (Phase 5)

{memgit-0.6.2 → memgit-0.8.0}/README.md

@@ -10,7 +10,7 @@ Version-controlled, cross-AI context that persists, diffs, rolls back, and syncs
 
 [![PyPI](https://img.shields.io/pypi/v/memgit)](https://pypi.org/project/memgit/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-245%20passing-brightgreen)](tests/)
+[![Tests](https://img.shields.io/badge/tests-404%20passing-brightgreen)](tests/)
 
 ---
 
@@ -34,9 +34,9 @@ You've probably already tried both. Here's why they hit a ceiling:
 
 ---
 
-## Proof — token savings you can measure
+## Proof — context costs you can measure
 
-Run this on your own store to see the actual numbers:
+Run this on your own store to see the actual numbers (measured where possible; estimates labeled):
 
 ```
 $ memgit stats
@@ -44,20 +44,17 @@ $ memgit stats
   Total memories:   108   (41 feedback · 23 user · 19 project · 12 reference · 8 convention · 5 lesson)
   Priority:          3 critical · 67 medium · 38 low
 
-  Token cost comparison:
-  ┌─────────────────────────────────────┬──────────────────┬───────────────────┬─────────────────────┐
-  │ Approach                            │ Tokens/session   │ vs full load      │ $/session (GPT-4o)  │
-  ├─────────────────────────────────────┼──────────────────┼───────────────────┼─────────────────────┤
-  │ claude.md / dump all memories       │ 12,840           │ 100%  baseline    │ $0.0321             │
-  │ memgit search (BM25 top-8)          │ 640              │ 5%  (95% savings) │ $0.0016             │
-  └─────────────────────────────────────┴──────────────────┴───────────────────┴─────────────────────┘
-
-  Weekly savings (10 sessions/week):
-    Tokens saved:   122,000/week
-    Cost saved:     $0.31/week  →  $15.86/year  (at GPT-4o input pricing, $2.50/M)
+  Context footprint  (measured where possible; estimates labeled)
+
+  Surface                                             Tokens
+  Full store (every memory as context)                12,840
+  Resume digest  (measured render)                       540
+  Recall block  (estimate: top-3 rules ≈ chars/4)        ~60
+
+  per-session injected ≈ 600 tokens (estimate) vs 12,840 tokens if the full store were loaded
 ```
 
-**Why such a big difference?** claude.md loads *all* context every session. memgit uses BM25 relevance scoring — it loads *only the 8 memories most relevant to the current session*, not everything you've ever recorded.
+**Why such a big difference?** claude.md loads *all* context every session. memgit injects a bounded resume digest plus BM25-matched recall — *only what is relevant to this session*, not everything you've ever recorded. The digest is measured by actually rendering it, and the store total is the real corpus size; nothing here is a simulated benchmark.
 
 ---
 
@@ -121,9 +118,11 @@ brew tap code4161/tap && brew install memgit
 
 **Windows:**
 ```powershell
+choco install memgit
+# or
 pip install memgit
 ```
-(`choco install memgit` is not live yet — the Chocolatey package is not on community.chocolatey.org. Use pip until it lands.)
+(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):**
 ```json
@@ -164,7 +163,7 @@ memgit onboard          # mines the repo, prints the bootstrap brief
 
 `onboard` first extracts a **repo digest** deterministically — git history (recent commit subjects, hot files/directories by churn, authors, branch, tags), detected stack from manifests, and the docs worth reading — using bounded, read-only probes that stay near-instant even on huge repositories. The brief then tells your AI agent exactly what to do with it: read only the listed files (no tree crawling), extract 10–20 durable facts (purpose, architecture, conventions, current state, gotchas), save each as a typed memory, and checkpoint the seed set. Paste it into a session — or don't: if the AI searches memory in a project that has none, the MCP server itself replies with the bootstrap instructions instead of a bare "no results."
 
-Memories are **project-scoped**: each carries the workspace it belongs to, searches boost the project you're standing in (global rules still surface), and the resume digest leads with *your current project's* recent work — not whatever repo you touched last night.
+Memories are **project-scoped, filter-by-default** (v0.7.0): each carries the workspace it belongs to, and searches, recall injections, and the resume digest (recent memories, checkpoints, depth hints) are **filtered** to the current project's family plus explicitly-global memories — another project's content never leaks in. Widen deliberately with `memgit search --all-projects` / `all_projects: true` (every hit then carries its `project` label), or hard-filter one project with `--project`. A memory with no project is **explicitly global** (applies everywhere): save one with `memgit add --global` or `project: ""`. A save whose project *cannot be determined* is never silently global — it's quarantined under `_unknown` (visible in `list` as `[?project]`, flagged by `lint`, surfaced nowhere) until you relabel it with `memgit doctor --relabel`.
 
 ---
 
@@ -255,10 +254,25 @@ The tool descriptions teach the AI **judgment** — "does this request depend on
 
 A project's hardest onboarding problem isn't *what* it does — it's *how to work in it*: which skill to invoke, which command to run, which tool to reach for. That lives in a `CLAUDE.md` or a skills folder the AI host may or may not be configured to read. memgit carries it for you.
 
-`memgit core seed` distills a compact operating guide from the project's existing skills + rule files. `memgit core sync` writes it into **every AI host's own rules surface** as a dedicated, memgit-owned file — `.claude/rules/memgit.md`, `.cursor/rules/memgit.mdc`, `.windsurf/rules/memgit.md`, `.clinerules/`, `.roo/rules/`, `.continue/rules/`, `.gemini/`, and a marker-block in Codex's `AGENTS.md`. It's **additive only** — memgit never touches your own config or content — and injected at session start, so any tool knows how to work in the project even when its native setup is missing.
+`memgit core seed` distills a compact operating guide from the project's existing skills + rule files. `memgit core sync` writes it into **every AI host's own rules surface** as a dedicated, memgit-owned file — `.claude/rules/memgit.md`, `.cursor/rules/memgit.mdc`, `.windsurf/rules/memgit.md`, `.clinerules/`, `.roo/rules/`, `.continue/rules/` — and marker-delimited blocks in the shared `GEMINI.md` (Gemini CLI auto-loads only that file) and Codex's `AGENTS.md`. It's **additive only** — memgit never touches your own config or content — and injected at session start, so any tool knows how to work in the project even when its native setup is missing.
 
 And it **learns**: a sidecar usage ledger tracks which memories actually get recalled, and the most-used ones are auto-promoted as pointers into the guide over time (budget-capped, decaying, and always subordinate to the repo's own rules — it never restates or overrides them). Drifted? `memgit core heal` rebuilds it.
 
+Since 0.8.0 it also **starts itself**: a project's first guide is created automatically once it holds a handful of memories, so the loop no longer waits on someone remembering to run `core seed`. The guide leads with what the project actually holds — "this project has N saved memories covering *topics*" — because a stated count of real prior work is evidence a model can act on, where an abstract instruction to check memory is something it can weigh against its own confidence and skip.
+
+---
+
+## Ranking you can prove
+
+Retrieval quality used to be adjusted on intuition. `memgit eval` replaces that with a measurement, using two frozen sets mined from the store itself:
+
+- **recall** — real prompts and the memories memgit actually surfaced for them. Measures *stability*: did a change break what used to work?
+- **synthetic** — each memory queried by its own `why`, expecting itself back, with the slug's own words stripped out of the query. Measures *correctness*, independently of any past ranking. (The recall set alone is circular — its answers came from the ranking under test.)
+
+Both report hit@1, recall@3/5/10 and MRR against a pinned baseline. There is deliberately no single blended score, and no fabricated "tokens saved" number.
+
+It earns its keep immediately. Two changes built for 0.8.0 looked obviously right and were measured wrong: a recency multiplier (cut — real-prompt hit@1 −0.020, MRR −0.018) and destructive stemming, which fixed its motivating query while costing hit@1 −0.038 overall (rebuilt as an additive field, then +0.020/+0.041/+0.019). A BM25 normalisation bug introduced in the same release was caught the same way.
+
 ---
 
 ## Depth advertisement, trackers & supersession (v0.6.0)
@@ -279,14 +293,14 @@ Measured across 289 real sessions: injected recall reached ~59% of them, but onl
 # Core (git-like)
 memgit init                       # initialize store (auto-detects best path)
 memgit onboard                    # bootstrap brief for an existing codebase
-memgit add <slug> <rule>          # stage a memory (--body detail, --project scope, --supersedes old-slug)
+memgit add <slug> <rule>          # stage a memory (--body detail, --project scope, --global everywhere, --supersedes old-slug)
 memgit commit -m "message"        # checkpoint current state
 memgit log                        # history
 memgit diff [sha1] [sha2]         # what changed
 memgit show <slug>                # display a memory
 memgit remove <slug>              # remove from active index (history preserved)
 memgit status                     # staged changes
-memgit search <query>             # BM25 relevance search
+memgit search <query>             # BM25 search, scoped to this project + global (--all-projects to widen)
 memgit rollback <ref>             # restore state to a checkpoint (HEAD~N or SHA)
 memgit resume                     # where we left off — session-start digest
 memgit merge <thread>             # three-way merge a thread into the current one
@@ -297,12 +311,23 @@ memgit core seed                  # draft a guide from this project's skills + r
 memgit core sync                  # deliver it into each AI host's own rules file (additive)
 memgit core show / edit           # view / curate the guide
 memgit core heal                  # self-repair a guide that has drifted
+                                  # (a project's FIRST guide is created automatically
+                                  #  once it holds 5+ memories — no command needed)
+
+# Retrieval evaluation — prove a ranking change helped
+memgit eval mine                  # freeze a regression set from real recall events
+memgit eval mine --synthetic      # non-circular set: query each memory by its own `why`
+memgit eval run --set recall      # hit@1 / recall@3,5,10 / MRR vs the pinned baseline
+memgit eval run --baseline        # pin the current result as the comparison point
+memgit eval run --misses 10       # inspect the cases where nothing relevant surfaced
 
 # Scale & proof
 memgit squash                     # compress old history (archives what it collapses)
-memgit gc                         # reclaim disk: sweep unreachable objects
-memgit stats                      # token savings + disk usage
-memgit lint                       # validate all memories
+memgit gc                         # reclaim disk: sweep unreachable objects + stale session caches
+memgit stats                      # measured context costs + disk usage
+memgit doctor                     # hygiene report: quarantined/_unknown memories, stale caches, orphaned usage
+memgit doctor --relabel map.json  # bulk re-project memories ({"slug": "Label" | ""}); one checkpoint
+memgit lint                       # validate all memories (flags unknown provenance)
 memgit fsck                       # verify store integrity
 
 # Import / export
@@ -351,6 +376,9 @@ memgit thread list / switch / create
 | **Windsurf** | MCP stdio | `memgit setup windsurf` |
 | **Cline / Roo-Code** | MCP stdio | `memgit setup cline` |
 | **Continue.dev** | MCP stdio | `memgit setup continue` |
+| **Codex** | MCP stdio (TOML) | `memgit setup codex` |
+| **Antigravity** | MCP stdio | `memgit setup antigravity` |
+| **Gemini CLI** | MCP stdio | `memgit setup gemini-cli` |
 | **ChatGPT (Custom Actions)** | HTTP + OpenAPI | `memgit serve --http` → import `http://localhost:7474/openapi.json` |
 | **Gemini API** | HTTP function calling | `memgit serve --http` + `llm-tool-definitions.json` |
 | **Any MCP tool** | MCP stdio | Add `{"command": "memgit", "args": ["serve"]}` to config |
@@ -411,7 +439,7 @@ git clone https://github.com/code4161/memgit.git
 cd memgit
 python -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
-pytest    # 245 tests, all passing, < 5 seconds
+pytest    # 404 tests, all passing, < 5 seconds
 ```
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).
@@ -436,14 +464,19 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 - [x] `memgit gc` — space reclamation (mark-and-sweep, lossless squash archive)
 - [x] Multi-agent write safety — store lock, auto-merge commits, `memgit merge`
 - [x] PyPI + Homebrew (tap) + npm published (v0.1.5)
-- [ ] Chocolatey (not yet live on community.chocolatey.org)
+- [x] Chocolatey — live on community.chocolatey.org (`choco install memgit`)
 - [x] Interactive setup wizard (`memgit setup`)
 - [x] Smart `memgit init` (auto-detects tool, no path needed)
 - [x] Lossless memories — full `body` alongside the compact rule (v0.3.0)
 - [x] Project-scoped memories + `memgit onboard` mid-project bootstrap (v0.3.0)
 - [x] VS Code extension (v0.1.5, Marketplace: code416-memgit.memgit)
+- [x] Codex + Antigravity support — MCP registration + `AGENTS.md` core guide (v0.8.0)
+- [x] `memgit eval` — measured retrieval quality, real + non-circular sets (v0.8.0)
+- [x] Usage-aware ranking — the recall ledger feeds relevance, not just the guide (v0.8.0)
+- [x] Automatic core-guide bootstrap — the self-improving loop starts itself (v0.8.0)
 - [ ] JetBrains plugin (Phase 3)
-- [ ] Semantic search via embeddings (Phase 4)
+- [ ] Semantic search via embeddings — gated on `memgit eval` showing a real gain (Phase 4)
+- [ ] Public benchmark numbers (LongMemEval, LoCoMo) (Phase 4)
 - [x] memgit.dev website (live)
 - [ ] Memory compression / auto-summarization (Phase 5)
 - [ ] Team access control + audit trail (Phase 5)

{memgit-0.6.2 → memgit-0.8.0}/memgit/__init__.py

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