v0.13.0

latest2026-10-08

A save whose parameters were swallowed into another field is refused instead of stored

PyPI npm (memgit-mcp)VS Code Homebrew MCP Registry GitHub

memgit add and the HTTP save apply the same check. Renaming the save parameters to names that do not read as element names needs a save-side evaluation against a live model first, and is not in this release.

+ Added

+The save response says what was stored: the length of each field, which ones arrived empty, and which values came from a default. It warns when no type arrived, when an unknown argument such as memory_type was sent, and when a rule runs past 400 characters (the damaged median was 992, the clean median 306)
+memgit doctor counts damaged memories by project, and memgit doctor --repair-markup splits them back into their fields: swallowed tags, related and supersedes merge into the real lists, a swallowed type or priority is restored, the timestamp is kept, and superseded memories are covered too. It is a dry run until --yes and writes one checkpoint. On the store it was built against it repaired 315 memories with 0 conflicts

✓ Fixed

✓save_memory refuses values that carry tool-call markup. A model sometimes closes a value with a tag named after the field, and the host then delivers the next parameters inside that value, so why, when, tags and type never arrive and the memory is stored with defaults. Measured on one machine: 748 of 3,025 save calls, every one answered ok. The refusal names the damaged field and the parameters found inside it, nothing is written, and the model retries in the same turn. Markup quoted on purpose inside backticks is allowed. Replayed over the 2,935 save calls still on disk, it refuses 725, and the only two loose matches it lets through quote the markup deliberately
✓Damaged text is no longer injected back into context. Exposure to a damaged memory raised one model's damage rate from 40.5% to 59.6%, because the markup reads as content. The session digest, the recall hook, the core guide and every read now show each field cut at the damage, and the store is never rewritten by a read

v0.12.0

stable2026-09-20

A project split across two labels raises no error, so doctor now volunteers it

PyPI npm (memgit-mcp)VS Code Homebrew MCP Registry GitHub

The company and component tiers land as foundation with nothing calling them: no scoping, ranking or save behaviour changes in this release. A client folder is not one project. One measured folder held six separate git repos and one workspace held thirteen sub-projects, and every save landed on whatever depth the session started from. Also internal: the TOON parser now carries unknown fields through a round trip, so a field written by a newer memgit is no longer dropped, silently and with a success report, by an older one.

+ Added

+memgit doctor reports scope losses by default, and --audit adds every row. A split label passes fsck, raises nothing and generates no bug report, so the only way anyone learns of one is a report that volunteers it. Four mechanisms are detected: the directory moved, the label was misspelled by hand, a short label was used where the workspace label was meant, and the two derivations disagreed. Measured on a 4,957-memory store: 2,190 memories did not surface in the workspace that owns them, and 2,168 of those were one relabel away
+Which label survives a repair is decided by the directory, not by the memory count. On a real store, healing toward the bigger pile would have kept a dead label holding 1,819 memories over the live one holding 18, and a misspelling holding 75 over the spelling holding 18, stranding both projects a second time
+Successor guessing is narrow on purpose. Matching a stranded label to a live one by its last path segment paired two different clients who happened to share a segment, which would have filed one client's memories under another. A candidate must be a trailing segment run of the stranded label and already hold memories, and ties break on directory depth

✓ Fixed

✓The two project-label derivations disagreed, and a test asserted the disagreement was correct. A label derived from a path and a label derived from a Claude Code projects directory name are supposed to agree byte for byte, or scoping silently breaks. They did not: the munge regex kept the underscore character and Claude Code rewrites it as a dash, so one directory produced two labels and neither half of that project could see the other. Zero of the roughly 2,000 directories in a real Claude Code projects folder contain an underscore. The parity test passed because it paired a path holding an underscore with a hand-written directory name that kept it, so both sides were built from the same wrong assumption and the one test written to catch this could not see it
✓Labels written before that fix are not stranded by it. Comparison folds the two forms and storage is untouched, so anything written under the old form keeps resolving, including memories arriving from an older writer or another machine, and nothing stored is rewritten

v0.11.0

stable2026-09-11

Concurrent writes stop losing memories, and the dependency range stops permitting an SDK with a published advisory

PyPI npm (memgit-mcp)VS Code Homebrew MCP Registry GitHub

A range has two ends and the previous release only checked one of them. This entry was written on 2026-09-20 from the changelog, after the release page was found two versions behind.

+ Added

+The mcp floor is raised from 1.0.0 to 1.28.1. Six advisories stand against the MCP Python SDK and the old range permitted every affected version. Five of the six are in the SDK's HTTP, SSE or WebSocket server transports and memgit serves stdio and instantiates none of them, so none was reachable in this package. What was wrong is the declared range, which is what a resolver picks from and what a supply-chain scanner reads
+memgit git push, pull and init --remote validate the remote and branch before they become git arguments. No shell was ever involved, but argv is not inert: git reads a leading dash as an option, and an ext:: URL is by definition a command line that git executes

✓ Fixed

✓The store lock did not exclude, and memories were silently lost. Measured: 3 of 120 concurrent runs dropped a memory, with three simultaneous lock holders observed. The object was written and readable, but the slug was absent from both the index and the current state, nothing raised, and fsck reported clean. Acquisition creates the lockfile and then writes the owner token, and between those two calls the file exists with zero bytes; the stale-lock breaker read that empty file, computed a process id of zero, skipped its liveness check and deleted a live lock. An unstamped lockfile is now a lock being born, never an abandoned one. After the fix: 0 of 250 runs lost a memory
✓Releasing the lock is ownership-checked. The old release unlinked unconditionally, so a holder whose lock had been broken would delete the new owner's lock on the way out, cascading one race into the next
✓memgit init no longer swallows every error while looking for existing memories. A genuine importer bug looked identical to having no memories yet

v0.10.0

stable2026-09-06

The server starts again, stops when you do, and stops re-reading the whole store

PyPI npm (memgit-mcp)VS Code Homebrew MCP Registry GitHub

Performance: the store is now loaded once, not once per call. Repository.list() re-read and re-parsed every object on every call — 4,075 gzip opens (429 ms) plus 4,075 TOON parses (718 ms), paid in full on every tool call. Memories are content-addressed, so a SHA-keyed cache can never serve stale content, and .memgit/cache/corpus.json carries a pre-parsed pool across processes. Measured on the live store: cold first search 2,035 ms to 401 ms, every later search 1,150 ms to 80 ms, and a session making eight memory calls goes from about 10.1 s to 1.0 s. Released from a repository cleaned of a supply-chain backdoor the same day.

+ Added

+memgit pro activate / status / deactivate — a Polar-issued licence key, validated against Polar's public customer-portal endpoint and cached at ~/.memgit/license.json (0600). Fail-open with a 14-day grace window, a 24-hour recheck cadence, and the key never echoed in full. MEMGIT_LICENSE_KEY serves headless MCP hosts and is never written to disk. No new dependency: the check uses urllib, so plain memgit stays click + rich + mcp
+The server releases its memory when it goes idle, dropping the parsed-object and tokenization caches after 15 minutes with no tool call (MEMGIT_IDLE_EVICT_SECONDS). Measured before the fix: six servers with living parents aged over seven hours, two still holding 126 MB and 112 MB. Eviction rather than exit — exiting would gamble on every MCP host reconnecting, and the corpus pool below makes a reload cost about 40 ms
+An orphan watchdog. Closed stdin already ends the process when a host exits, verified end to end one second after a SIGKILL of the parent; this is the backstop for when it does not
+memgit savings — what memory cost, against what finding the same fact would have cost. Matching runs over passages rather than whole files, because a 40 KB document holds half the vocabulary of almost any memory. A memory no file carries is never converted into tokens: it is reported as a count, because without memgit those facts are not found more expensively, they are not found. Measured on a 4,075-memory store against a 1,958-file workspace: 40.6% of recalled memories exist in no file at all, and for the rest reading costs 94x what recall costs

✓ Fixed

✓mcp is pinned below 2.0, which is what makes memgit installable again. The MCP SDK released 2.0 on 2026-07-28; memgit asked for mcp>=1.0.0 with no upper bound, so from that day every fresh install resolved to 2.x, which removed the decorators this server is built on, and the server crashed on startup before answering a single request. Both routes were affected: pip, and the npm wrapper, which builds a clean venv on first run. Measured: a clean install resolved mcp 2.1.1 and memgit serve died with AttributeError: 'Server' object has no attribute 'list_tools'; with the pin it resolves 1.29.1 and answers initialize
✓An incompatible SDK now says so, in words, with the command that fixes it. MCP hosts do not surface a server's stderr, so the old failure reached the user as "the server failed to start" with no cause. The check runs before the decorators are touched and names the version found, the version needed, and the extra step for the npm route
✓The server reports its own version again. Server() was constructed without version=, so the SDK filled in its own and every host displayed memgit's version as 1.29.1 — on a defect whose only symptom is silence, that was the one field that could have told anyone which memgit they were running

v0.9.1

stable2026-08-14

Findable where the users actually are — the MCP Registry manifest

PyPI npm (memgit-mcp)Homebrew GitHub

memgit shipped on five package channels and appeared on zero MCP discovery surfaces; Glama auto-crawls 72,234 servers and did not list us, while competitors did. That is a distribution gap, not a product gap — and it means the absence of inbound interest had never actually been tested. Ownership verification reads what is published, not what is committed, so the markers only take effect from this version onward.

+ Added

+server.json — the official MCP Registry manifest, validating against the 2025-12-11 schema and declaring both install routes, since the registry stores metadata only and both artifacts already exist: memgit-mcp on npm and memgit on PyPI (invoked as memgit serve), each over stdio. No required environment variables, so the zero-config path is preserved
+Namespace dev.memgit/memgit, the reverse-DNS form of a domain we own, proven by DNS rather than by a GitHub account. Chosen before the first publish deliberately: the registry treats a name change as a separate server entry, not a rename
+Ownership markers — mcpName in the npm package manifest and an mcp-name: comment in the README, the two things the registry reads from the published artifacts to prove the packages are ours

v0.9.0

stable2026-08-05

Durability that does not wait for a human — automatic off-machine backup

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

memgit's whole premise is that the AI is the operator, and backup was the one place that premise broke: off-machine safety required someone to remember a command and then keep running it. On this project's own store — 1,734 memories, five weeks of daily use — it had never been run once, and the entire memory set existed on a single disk with no copy anywhere. A maintenance task that needs a human command is a maintenance task that will not happen.

+ Added

+memgit backup — automatic off-machine durability, run unattended from the end-of-session sync path. backup status reports the last copy and every destination available; backup now forces one; backup set pins a destination; backup off/on control the automatic path
+Destination discovery — a configured git remote ranks first (it is the user's own explicit choice), then cloud-synced folders already present on the machine (iCloud Drive, Dropbox, Google Drive, OneDrive), then writable external volumes
+The safety boundary is network egress, not effort. Local destinations are used automatically: memgit copies files, opens no connection and signs up for no service. A git remote is pushed to only if one is already configured — memgit never invents a remote and never sends memories to a host the user did not pick. That line matters because memories are not neutral text: a prior audit on this very store found client credentials among them
+One archive, not a directory tree. The audited store is 203 MB across 10,295 small object files, and handing a cloud-sync client 10k files to reconcile is how you get a sync client that never finishes. Backups are a single memgit-store.tar.gz (171 MB, about 7 s) plus a RESTORE.txt, verified end to end: extract, point memgit at it, 1,741 memories restored with a clean fsck
+Atomic replacement — the archive is staged and renamed over the target, previous copy kept until the new one lands. An interrupted backup must never leave a corrupt file where a good one used to be: that failure does not lose data loudly, it leaves something that looks safe

✓ Fixed

✓Test isolation: unattended backup could write to the developer's real cloud folder. Found by inspecting the first live run — a test exercising the sync path had mirrored its temp store into an actual iCloud directory, because destination discovery reads the true home while the store was a temp path. The unattended path now refuses whenever MEMGIT_STORE or PYTEST_CURRENT_TEST is set; an explicit backup now is unaffected, because that is someone asking on purpose

v0.8.1

stable2026-08-05

The core guide's skill list was unbounded

PyPI npm (memgit-mcp)Homebrew GitHub

✓ Fixed

✓Skill description frontmatter is written to persuade a model to invoke the skill and routinely runs 600+ characters, and the guide copied it verbatim. Caught immediately after 0.8.0 by running core heal on a real store: 18 skills produced 6,968 of the guide's 9,425 characters, pushing the measured per-session floor from 2,765 to 3,710 tokens — on the surface that is injected every session on every host. Descriptions are now trimmed to a routing summary at a sentence or word boundary; the full text is in the skill itself, one read away

v0.8.0

stable2026-08-05

Retrieval you can prove, and adoption that starts itself — memgit eval

PyPI npm (memgit-mcp)Homebrew GitHub

Two audits fed this release. The first produced five phases that were built, tested and then never released — every host kept running 0.7.0, so measured-token honesty, the metrics ledger, host attribution, write-time conflict detection and Codex/Antigravity setup were all dead code in production for two weeks. The recency multiplier built for this release was measured harmful (real-prompt hit@1 -0.020, MRR -0.018) and cut before shipping; staleness is a write-time problem, not something a blunt global age multiplier fixes.

+ Added

+memgit eval — a ruler for ranking. eval mine freezes a regression set from the store's own history (real prompts, and the memories prompt-recall actually surfaced for them); eval mine --synthetic builds a non-circular set that queries each memory by its own why and expects itself back. The two answer different questions and are kept separate: the first measures stability against the ranking that produced the transcripts, the second measures correctness independently of it. There is deliberately no single blended score — a change that trades hit@1 for recall@5 is a judgement the operator should see both sides of
+Measured-usage term in ranking. The store had always recorded which memories actually get surfaced (17,933 events on the audited store) and decayed those hits on a 14-day half-life, but only the core guide consumed it while ranking ignored ground truth it was already collecting. Measured: real-prompt hit@1 +0.015, recall@3 +0.020, MRR +0.016. Unused memories are never penalised, so a fresh correction cannot be buried under an old favourite
+Additive stem matching — queries and memories now meet on stems as well as exact terms (deploy finds deployment-vercel), via a separate low-weight pseudo-field rather than by folding the real fields. Weight (0.35) chosen by sweep on the harness, not by taste. Measured against 0.7.0: real-prompt hit@1 +0.020, recall@3 +0.041, MRR +0.019
+Automatic core-guide bootstrap. This was the adoption bug: seed and sync were manual and nothing ever called them, so a project where no human ran them had no guide and no rules file reached any host. On the audited install, 30 projects had memories and 6 had a guide; in the other 24, memgit's entire presence in Cursor/Codex/Antigravity was an MCP tool description — the exact surface the hook design had already measured as too weak to rely on
+Project-label folding on save. A label that is a trailing segment of exactly one known label, and that holds no memories of its own, is folded onto it — with a warning in the save response, never silently. An established label is never folded away in either direction, which is what makes it safe

✓ Fixed

✓Antigravity was never actually wired. setup antigravity wrote to a 1.x per-app path, but Antigravity 2.x shares one config across the IDE, the agy CLI and the SDK. Verified on a live install: across 8 Antigravity sessions and 6,785 transcript lines there were zero memgit tool calls — it had been reduced to shelling out to the CLI with the user re-explaining memgit in the prompt each time
✓Antigravity received no core operating guide at all — it was absent from the delivery targets
✓Depth hints advertised identifiers (commit SHAs, bare numbers, dates) as topics to search. The shape filter is now shared by the memory index, context recall and the prompt-recall hint; the SHA test requires a digit, so words spelled entirely from a-f (decade, faced, added) survive as real topics
✓Depth hints named nothing. Measured across 886 real sessions, the bare-count form ("+34 more saved on 'crypto'") was acted on in only 20.5% — four times in five the model was told depth existed and moved on. The hint now names the strongest unshown memory, deterministically: a count is not evidence, a specific rule the reader can see is missing is
✓Search re-tokenised the whole corpus three times per query, with no cache; profiling put 76% of runtime in re.findall. Tokenisation is now memoised by content SHA. Measured 6.8x faster on the audited store: 46 ms to 6.8 ms per search, and the cost stops growing linearly with store size
✓BM25 length normalisation was inconsistent with the new stem field — doc_len excluded it while avg_len included it, silently shifting every score. Caught by the harness, which is the point of the harness

v0.7.0

stable2026-07-19

Project isolation — filter-by-default scoping, provenance quarantine, and the self-improving core loop actually runs

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

Driven by a full empirical audit: 81 memories (15% of the store, including client credentials) had leaked into every project via silent-global saves from MCP servers whose cwd never resolved; a zero-memory project's first session opened with ~38 foreign items. All surfaces are now sealed by default. 294 tests (47 new).

+ Added

+Filter-by-default scoping on every surface — search, prompt-recall injection, resume checkpoints, and depth hints are restricted to the current project's family plus explicitly-global memories. A session in project A never sees project B's content; widen deliberately with --all-projects / all_projects: true (every hit then carries its project label) or hard-filter with --project
+Provenance quarantine — a save whose project cannot be determined is never silently global: it lands under _unknown (visible in list as [?project], flagged by lint, surfaced nowhere) until relabeled. Explicit global is now an intentional act: memgit add --global or project: ""
+detect_project() — one detection path everywhere: MEMGIT_PROJECT > hook cwd > CLAUDE_PROJECT_DIR > cwd; the MCP server re-detects per call instead of freezing the server process's startup cwd
+memgit doctor — store hygiene: report quarantined/global memories, bulk --relabel from a JSON mapping (timestamps preserved, one checkpoint), --prune-usage, --clean-caches (30-day session-cache GC, also run opportunistically on sync)
+Any-install-method hook binary resolution — memgit setup hooks writes the absolute path of the binary that is actually running (pipx, pip, brew, npm, choco), falling back to PATH lookup, then python -m memgit.cli
+Resume digest hard budget (9.5 KB) — measured on real sessions, 78% of digests exceeded the host's 10 KB inline hook limit and arrived truncated; the digest now trims itself (core guide and status board are never trimmed)

✓ Fixed

✓The 0.5.0 self-improving core-guide loop had never run in production — the installed Stop-hook template's cd <store> && memgit sync poisoned the cwd-derived project label, so auto-promotion silently no-oped every session. The cd is gone (sync finds the default store from any cwd) and auto-core is guarded against store-cwd sessions
✓Gemini delivery was inert — .gemini/memgit.md is a file Gemini CLI never loads. The core guide now ships as a marker-delimited block in GEMINI.md (the Codex mechanism); the old inert file is cleaned up on sync
✓CLI search parity — search now applies the same project boost as MCP and prints the project field in table and --json output (it previously printed foreign hits with no origin at all)
✓memgit stats no longer fabricates savings — the dump-everything strawman baseline, phantom critical-overhead figure, and invented weekly/annualised projections are gone; what remains is measured (the digest is actually rendered) or labeled as an estimate
✓Folded/multi-line YAML descriptions in seeded core guides are no longer truncated mid-sentence
✓Test suite fully isolated from the live store via MEMGIT_STORE (exclusive when set)

v0.6.2

stable2026-07-13

Depth hint excludes project-label tags (shared noise rule)

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

✓ Fixed

✓The '+N more saved on <tag>' recall hint advertised project-label tags ('+75 more saved on business') — the third surface of the same noise class. The exclusion rule (a project label and its components are not topics) is now one shared helper applied by the memory index, context recall, and the prompt-recall depth hint

v0.6.1

stable2026-07-13

Context-recall stops hinting project-label tags

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

✓ Fixed

✓Caught live minutes after installing 0.6.0: reading any file under a workspace hinted the workspace's own label as a topic ('77 memories tagged business'). The PostToolUse hook now excludes the current project label and its components from matching

v0.6.0

stable2026-07-13

The passive layer advertises what the active layer knows — supersession, trackers, depth counts

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

Measured across 289 real sessions: hook recall was delivered in ~59% of sessions but only 6.8% ever ran an active search — the model treated the injected sample as the memory rather than a teaser of a queryable store. 0.6.0 makes every injected block carry a truthful advertisement of the store's depth. (Re-measured after release: conversion rose to 11.1%.)

+ Added

+First-class supersession — a correction names the memories it replaces (supersedes=[old-slug]) instead of sitting beside them; superseded memories are hidden from search, recall, and resume by default, and resurrect if the superseder is removed
+Tracker memories (tr) + status board — one live-status memory per entity (deploy, draft, migration, campaign), updated by re-saving the same slug; rendered as a status board at the top of the resume digest under 'memgit is authoritative; files may lag'
+Memory index — the digest ends with tag→count depth advertisements plus the exact search_memories call to go deeper
+'+N more' count-line in prompt recall, and context-triggered recall (PostToolUse on Read/Grep/Glob) — a one-line hint when memories exist about the file being read, served from a tagmap cache without loading the store
+Core-guide seed nudge in the resume digest for projects with history but no guide

v0.5.0

stable2026-07-11

Core operating guide — per-project, always-on, cross-host, self-improving

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

+ Added

+New memory type co (core) — a per-project navigation aid injected IN FULL at session start, explicitly subordinate to the repo's own rules
+memgit core command group — show / set / edit / seed (drafts the guide from the project's existing skills + rule files) / sync / refresh / heal
+Cross-host delivery — core sync writes a dedicated memgit-owned rule file into each detected host's native surface (Claude Code, Cursor, Windsurf, Cline, Roo, Continue, Codex AGENTS.md marker block), additive and idempotent
+Self-improving accumulation — a sidecar usage ledger counts which memories actually surface; the most-used are auto-promoted as pointers into the guide's auto-managed section, budget-capped and decayed on a two-week half-life
+delete / rm / del aliases and did-you-mean suggestions on mistyped commands (0.4.1)

v0.4.0

stable2026-07-07

Guardrail-grade memory — recall and capture become hook-enforced, not voluntary

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

The number that drove this release: across an audit of 166 real Claude Code sessions, hook-injected context was delivered in 100% of them while the model voluntarily called a memory tool in 6%. Sessions found production root causes and client decisions and saved none of them. What a hook enforces happens; what a tool description suggests mostly doesn't. 0.4.0 moves recall and capture into hooks, and fixes every defect from a full end-to-end audit. 160 tests (32 new).

+ Added

+Per-prompt auto-recall (UserPromptSubmit hook) — every prompt is BM25-matched against the store and relevant memories are injected as context, so recall no longer depends on the model remembering to search. Silent unless a match clears a store-size-aware relevance bar (an absolute bar mutes recall on young stores, where BM25 IDF collapses); per-session dedup so nothing is injected twice
+Capture guard (Stop hook) — a session that did real work (25+ tool calls) and saved nothing gets blocked ONCE with instructions to save durable facts, or finish if nothing qualifies. Never nags twice; detection is anchored to real tool_use JSON so a tool name appearing as plain text doesn't count as a save
+memgit setup hooks now installs the full set — SessionStart resume, UserPromptSubmit recall (--no-recall to skip), Stop capture-guard (--no-guard to skip) + async sync. Previously only SessionStart was wired, so MCP-saved memories on hook-less machines were never checkpointed
+Project-family affinity — search boost, resume, and the fresh-project nudge now match hierarchically: a session in BITS/bits_back counts BITS memories as its own (exact > family > global). Before, any session started in a subdirectory silently lost all project scoping

✓ Fixed

✓CRITICAL — CR/CRLF corruption + field injection: a body containing \r was truncated at the first carriage return on read-back, and the lost tail re-parsed as injected fields (a crafted body could override RULE:). \r is now escaped like \n; round-trip is byte-exact. Windows MCP clients and pasted CRLF text hit this constantly
✓CRITICAL — silent memory loss on space-containing slugs: a memory whose frontmatter name had spaces staged fine but vanished on every index read, with no error. Slugs are normalized at every write surface; the index reader tolerates legacy entries
✓Project-label munging now matches Claude Code byte-for-byte (_ and . were munged differently), so memories synced from projects like bits_back can actually match their own workspace at recall time
✓Cross-project leak in resume — a memory-less project fell back to a global recency dump (client A's content in client B's first session). Fallback is now family + global only; critical (p3) rules are scoped the same way instead of firing in every project
✓MCP save_memory now checkpoints immediately as save: <slug> [type] — attributable and rollback-able — instead of staging invisibly until the next sync; sync commits staged work even when no markdown sources exist
✓Rich markup no longer interpreted inside displayed user content ([pj], [[wikilinks]], shas like [fadc1234] were eaten as style tags); lint exits non-zero on issues; MCP unknown-tool returns a proper protocol error; save_memory accepts type as an alias for type_code

v0.3.1

stable2026-07-03

Git-aware onboarding — the repo digest

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

Requested minutes after 0.3.0 shipped: on very large repos, telling the AI to 'go read the codebase' is slow and error-prone. Now memgit does the deterministic part itself and hands the model facts.

+ Added

+memgit onboard now mines the repo itself before printing the brief: a deterministic, read-only digest of git history (recent commit subjects, hot files/directories by churn, authors, branch, latest tag) plus detected stack from manifests, docs worth reading, and CI presence
+Every probe is timeout-guarded and commit-capped — measured 0.19 s, safe on very large repositories. The brief instructs the AI to trust the digest and read only the listed files instead of crawling the tree: extraction a tool can do deterministically is no longer left to the model
+memgit onboard --json emits the raw digest for tooling; falls back to the generic reading plan when there is no git repo

v0.3.0

stable2026-07-03

Lossless memories · project-scoped relevance · mid-project onboarding · guided init

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

Born from the first real multi-project dogfooding audit: 8 projects' memories were flattened into one pile, rich memories were ~98% truncated on import, and a store adopted mid-project had no way to seed itself. All three are structural fixes, not patches — 122 tests (25 new).

+ Added

+body field — memories are now lossless. The full long-form content (multi-line markdown) is stored alongside the compact one-line rule; search results stay lean, get_memory returns everything. The Claude Code importer previously kept only the first paragraph truncated to 400 chars — a real 17,500-char project memory was being stored as 360 chars
+project field end-to-end — the importer derives the project, the MCP server auto-detects the current workspace (MEMGIT_PROJECT overrides), search boosts the current project's memories (global rules still surface), resume_session leads with the project you're standing in, save_memory stamps it; hard filters on search/list; per-project breakdown in stats
+memgit onboard — adopt memgit mid-project: prints the bootstrap brief for an AI operator to seed the store from an existing codebase (README, docs, manifests, git history → 10–20 typed memories → checkpoint). The MCP server also nudges bootstrap when a search misses in a project with zero memories
+Guided memgit init — auto-finds existing Claude Code memories (~/.claude/projects/*/memory), reports how many across how many projects, offers the import on the spot, prints next steps
+Cross-project slug collision safety — importing a slug owned by a different project re-slugs (<slug>--<project>) instead of silently overwriting
+memgit add --body / --project; save_memory body + project params; body content is BM25-searchable at low weight

✓ Fixed

✓Multi-line content in any TOON field no longer breaks parsing (\n-escaped on serialize, unescaped on parse; existing objects' SHAs unchanged)
✓Importer kept real metadata: frontmatter description stored as searchable desc, tags derived from the project instead of type-code junk, optional priority:/tags: frontmatter honored, source records the originating file
✓sync checkpoint messages name what actually changed (sync: +1 ~3 (crypto-module, …)) instead of a wall of identical auto-sync messages

v0.2.0

stable2026-07-02

Session resume · garbage collection · multi-agent write safety · AI-operator surface

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

Born from a real incident: asked to 'proceed on the pending tasks', an AI answered from the file that happened to be open instead of the memory store. resume_session + setup hooks make the store's record of last actions the session's starting point. Every performance and token figure above was measured, not estimated.

+ Added

+memgit resume — bounded 'where we left off' digest: last checkpoints, staged work in flight, recent + critical memories (~335 tokens measured, flat from 12 to 500 memories); --plain and --json modes
+resume_session MCP tool + GET /resume HTTP endpoint — AI agents get the authoritative record of last actions instead of guessing session state from open files
+memgit setup hooks — one command wires a Claude Code SessionStart hook so every new session auto-starts with the resume digest in context
+memgit gc — mark-and-sweep space reclamation: only provably-unreachable objects are deleted, reflogs trimmed; benchmark: a 2,000-checkpoint store shrank 94% (39.5 MB → 2.2 MB) with fsck clean
+memgit merge <thread> — three-way, common-ancestor merge for branch-per-agent workflows; conflicts resolve to the newest memory, an edit always beats a delete
+Store-wide write lock (0.08 ms overhead) + concurrent-commit auto-merge: agents writing in parallel can no longer clobber or lose each other's updates; MEMGIT_AUTHOR attributes checkpoints per agent
+History ops now O(1) in chain length — SHA resolution 92.7 ms → 0.08 ms at 2,000 checkpoints; log --skip pagination
+AI-operator surface: resume/status/stats emit a maintenance hint (naming the exact command) when history passes 500 checkpoints or 50 MB; gc/squash/stats grew --json for token-cheap machine output
+memgit setup gemini-cli — register with Gemini CLI (~/.gemini/settings.json)

✓ Fixed

✓squash silently discarded staged (uncommitted) memories — staged work now survives compaction
✓squash now archives every collapsed checkpoint (one line each) to .memgit/logs/archive/ before rewriting — compaction is lossless-in-substance, gc never touches the archive
✓python -m memgit.cli was a silent no-op (missing __main__ guard) — the documented MCP-registration fallback would have produced a dead server
✓MCP server instructions are now actually sent in the handshake (previously defined but never passed); tool descriptions teach judgment, not keyword triggers

v0.1.5

stable2026-07-02

Critical fix: Claude Code MCP registration targeted the wrong file

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

Found by dogfooding: the memgit MCP tools never appeared in a real Claude Code session. Every ≤0.1.4 Claude Code registration was a silent no-op — upgrading and re-running setup fixes it in one command.

+ Added

+Setup registration test suite — correct target file, idempotency, state preservation, invalid-JSON guard, legacy cleanup (61 tests total)

✓ Fixed

✓memgit setup claude-code wrote mcpServers to ~/.claude/settings.json, which Claude Code ignores — MCP tools never loaded. Now registers in ~/.claude.json (user scope) and cleans up the stale legacy entry. If you registered with ≤0.1.4, re-run: memgit setup claude-code
✓setup no longer overwrites a config file it cannot parse — invalid JSON aborts instead of clobbering (protects ~/.claude.json, which holds all Claude Code user state)
✓Claude Code detection uses ~/.claude/ instead of misfiring on the home directory

v0.1.4

stable2026-07-02

Rollback command · store auto-detect · accuracy fixes · Copy for LLM

PyPI npm (memgit-mcp)VS Code Homebrew GitHub

First release where CLI, npm MCP wrapper, VS Code extension, and Homebrew all ship the same version. Chocolatey remains pending moderation.

+ Added

+memgit rollback <ref> — restore state to any checkpoint (HEAD~N or SHA prefix), git-revert style: history preserved, nothing deleted; --dry-run and -y flags
+Repository.resolve_ref() — resolves HEAD, HEAD~n, and abbreviated checkpoint SHAs
+Store auto-detect fallback — CLI and MCP server find the store from any directory
+Optional exact token counting via tiktoken: pip install "memgit[tokens]"
+Copy for LLM on memgit.dev — one-paste agent adoption prompt (OS-aware install + memory doctrine), also served at memgit.dev/llm.txt

✓ Fixed

✓Priority 1 (low) memories were silently stored as priority 2 — now round-trips all priorities
✓memgit stats: fabricated comparison row removed; search-cost estimate now deterministic
✓GPT-4o input price corrected to $2.50/M tokens — all $ savings figures halved accordingly
✓TOON efficiency claims corrected: ~5–10% leaner than markdown (the 95% figure is BM25 top-k retrieval)
✓Docs and USAGE.md match the real CLI surface — no invented flags

v0.1.3

vscode2026-07-02

VS Code Marketplace launch · memgit.dev live

VS Code GitHub

Public launch milestone. VS Code–extension release; the CLI stays at v0.1.2 on PyPI / Homebrew / npm.

+ Added

+VS Code extension published to Marketplace — code416-memgit.memgit
+Extension ID: code416-memgit.memgit (install: code --install-extension code416-memgit.memgit)
+memgit.dev landing page deployed to Vercel production
+Multi-format favicon suite (SVG + PNG 16/32/180/192/512)
+Dynamic Open Graph social preview card (1200×630)
+XML sitemap and PWA web manifest

v0.1.2

stable2026-07-01

Homebrew tap · npm MCP wrapper · Chocolatey · GitHub Actions CI

PyPI npm (memgit-mcp)Homebrew GitHub

+ Added

+Homebrew tap: brew tap code4161/tap && brew install memgit
+npm MCP wrapper package: npx memgit-mcp (package: memgit-mcp on npm)
+Chocolatey package submitted (pending moderation)
+GitHub Actions workflow for automated PyPI publish on git tag
+memgit setup all — auto-detects and registers every installed AI tool
+Per-tool setup: Cursor, Windsurf, Cline, Roo-Code, Continue.dev
+HTTP server (FastAPI) for ChatGPT Custom Actions and Gemini function calling
+OpenAPI 3.1 spec (openapi.json) for GPT integration
+Provider-agnostic tool definitions (llm-tool-definitions.json)

✓ Fixed

✓Lint rule length raised from 200 → 400 chars to match real Claude Code memory sizes
✓Slug regex relaxed to allow underscores (^[a-z0-9_-]+$)

v0.1.0

initial2026-07-01

Initial release — core CLI, TOON format, MCP server, Claude Code integration

GitHub

The first public release. The CLI is feature-complete for local use with Claude Code.

+ Added

+Core content-addressed object store with SHA-256 content hashing
+TOON (Token-Optimised Object Notation) format — 40% more token-efficient than JSON
+Repository layer: add, commit, diff, log, list, remove, fsck, thread
+MCP stdio server with 5 tools: search_memories, get_memory, list_memories, save_memory, get_checkpoint_log
+BM25 relevance scoring for memory search
+Claude Code memory file importer (memgit import claude-code)
+Auto-sync hook integration (memgit setup claude-code installs Stop hook)
+Abbreviated SHA resolution (git-style 8-char short refs in diff)
+Interactive D3.js graph visualization of memory relationships (memgit graph)
+27-test suite with 100% pass rate

✓ Fixed

✓Abbreviated SHA resolution in diff command (FileNotFoundError on short refs)

Releases

v0.13.0

+ Added

✓ Fixed

v0.12.0

+ Added

✓ Fixed

v0.11.0

+ Added

✓ Fixed

v0.10.0

+ Added

✓ Fixed

v0.9.1

+ Added

v0.9.0

+ Added

✓ Fixed

v0.8.1

✓ Fixed

v0.8.0

+ Added

✓ Fixed

v0.7.0

+ Added

✓ Fixed

v0.6.2

✓ Fixed

v0.6.1

✓ Fixed

v0.6.0

+ Added

v0.5.0

+ Added

v0.4.0

+ Added

✓ Fixed

v0.3.1

+ Added

v0.3.0

+ Added

✓ Fixed

v0.2.0

+ Added

✓ Fixed

v0.1.5

+ Added

✓ Fixed

v0.1.4

+ Added

✓ Fixed

v0.1.3

+ Added

v0.1.2

+ Added

✓ Fixed

v0.1.0

+ Added

✓ Fixed

Stay up to date