Show HN: Memgit, versioned memory for Claude Code across all your machines

A developer using the handle code4161 released Memgit, an MIT-licensed tool that adds versioned, end-to-end encrypted memory sync for Claude Code across multiple machines and AI tools including Cursor, Codex, Windsurf, Gemini CLI and any MCP host. Memgit imports Claude Code's existing machine-local memory, stores every change as a checkpoint with `memgit diff` and `memgit rollback`, and offers optional cloud sync at $12 a month or $99 a year after a 14-day free trial, with the server storing ciphertext only. The tool requires Node and Python 3.11+ and installs via pip, Homebrew, Chocolatey, or a Claude Code plugin marketplace command.

The same memory in every session, on every machine, in every tool. Versioned, so a wrong memory is one command to undo. Claude Code now remembers things on its own, on one machine. Its docs are plain about the limit: auto memory is machine-local and is not shared across machines or cloud environments. memgit is the layer on top. It imports what Claude Code already keeps and adds the three things built-in memory does not do: - Every machine. Your laptop, your desktop and a server hold the same memory, synced end-to-end encrypted. - Every tool. Claude Code, Cursor, Codex, Windsurf, Gemini CLI and any MCP host read and write one store. - History. Every change is a checkpoint. memgit diff shows what an agent changed and memgit rollback puts it back. Unedited terminal recording, regenerated from the released package on every release. Claude Code two commands inside Claude Code, nothing else to set up : /plugin marketplace add code4161/claude-plugins /plugin install memgit@memgit The plugin starts the memory server, creates the store on first use and adds the hooks that bring memory in at session start and save what a session learns. It needs Node and Python 3.11+ on the machine. Any other tool, or the full CLI: pip install memgit or: brew tap code4161/tap && brew install memgit memgit init creates the store, imports the memory Claude Code already keeps, and offers to connect every AI tool it finds on this machine That is the whole setup. Restart your AI tool: it now starts each session with your memory and saves what it learns. memgit resume shows exactly what it will see. Any MCP host by config needs Python 3.11+ on PATH; the first run installs memgit into its own environment and creates the store : { "mcpServers": { "memgit": { "command": "npx", "args": "-y", "memgit-mcp" } } } Windows: choco install memgit new versions can wait a few days in Chocolatey moderation; pip install memgit always has the latest . memgit cloud signup on the first machine: one passphrase, then it syncs on its own memgit cloud login on every other machine Every save goes up in the background and other machines' memories arrive at session start and while you work. The server stores ciphertext only; the passphrase never leaves your machine. Free for 14 days with no card, then $12 a month or $99 a year. The local engine, the store, the MCP server and every command are MIT and never gated, and a lapsed plan never locks your data: it stays on your machine, readable and exportable. Until a store is connected, memgit may show one line about this, decided on your machine and sent nowhere: when the store reaches 50 and 250 memories, when it is opened on a second machine, and after an export or a backup, each at most once, for example "214 memories are on this machine. memgit cloud signup puts them on your other machines too 14 days free, no card ." Turn it off with memgit cloud hint off or MEMGIT NO SYNC HINT=1 . memgit fsck every object verified by SHA-256 memgit stats what your context costs with and without memgit, measured on your store memgit cloud auto status whether anything leaves this machine, and when it last did With no cloud login and no licence key, memgit talks to nothing. You've probably already tried both. Here's why they hit a ceiling: | Capability | claude.md | mem-search plugin | memgit | |---|---|---|---| | Loads only relevant context | ❌ loads everything | | ✅ BM25 search — top-k per query | | Project-aware across a multi-repo life | ❌ per-file | ❌ | ✅ memories carry a project ; the current workspace ranks first | | Adopt on an existing codebase | ❌ starts blank | ❌ starts blank | ✅ memgit onboard — seed the store from the repo in one pass | | Version history | ❌ | ❌ | ✅ full commit log | | Diff between sessions | ❌ | ❌ | ✅ memgit diff | | Roll back a wrong memory | ❌ manual edit | ❌ | ✅ memgit rollback | | Works in Cursor, Windsurf, GPT | ❌ Claude only | ❌ Claude only | ✅ all via MCP / HTTP | | Team sync | ❌ copy-paste files | ❌ | ✅ memgit git push | | Scales to 10k+ sessions | ❌ file grows | ❌ search slows | ✅ memgit squash | | Measurable token savings | ❌ | ❌ | ✅ memgit stats | | Export / import standard format | ❌ | ❌ | ✅ TOON + git | Run this on your own store to see the actual numbers measured where possible; estimates labeled : bash $ memgit stats Total memories: 108 41 feedback · 23 user · 19 project · 12 reference · 8 convention · 5 lesson Priority: 3 critical · 67 medium · 38 low 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 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. memgit's data model maps exactly to git: | memgit | git | |---|---| | mnemonic | file | | MindState | tree | | checkpoint | commit | | thread | branch | | memgit commit | git commit | | memgit diff | git diff | | memgit log | git log | | memgit squash --keep-last 100 | git rebase -i --autosquash | | memgit git push | git push | This is not metaphorical — memgit uses a content-addressed object store SHA-256 blobs identical to git's architecture. Every memory has a stable SHA. Identical content has identical SHAs. Old state is always recoverable. Every memory is a readable .toon file under memories/ . Push your entire memory set to GitHub with standard git: memgit git init --remote git@github.com:yourteam/ai-memory.git memgit git push Teammates pull and start with your AI's learned rules from session 1: git clone git@github.com:yourteam/ai-memory.git ~/.claude/memgit-store memgit setup all You can grep , git blame , and git diff your memories just like code: grep -rl "database" ~/.claude/memgit-store/memories/ git log --follow memories/no-db-mock.toon git diff HEAD~7 memories/ Memory tools have a cold-start problem: install one halfway through a project and it knows nothing — there's no initial point, and context only trickles in from future sessions. memgit solves this with a one-time seeding pass: cd your-project 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, 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 . Ask an AI "can we proceed on the pending tasks?" in a fresh session and it will guess from whatever file happens to be open. memgit resume replaces the guess with the record: memgit resume last checkpoints, work in flight, recent + critical memories memgit resume --plain plain text, for piping into an AI context memgit resume --json for tooling Wire it into Claude Code so memory becomes automatic — no tool call, no judgment required: 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 ''" 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 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. The resume digest is deliberately bounded ~350 tokens measured on a 500-memory store : rules are clipped, the critical list is capped, and full text is one get memory call away. After months of use, your checkpoint history grows. Squash compresses it, gc reclaims the disk: memgit squash --keep-last 100 keep last 100 checkpoints, squash everything older memgit squash --older-than 30 squash everything older than 30 days memgit squash --dry-run preview first memgit gc delete unreachable objects, trim reflogs memgit gc --dry-run preview memgit gc --squash-keep 200 compact history, then sweep The current memory state is always preserved — and squash is lossless-in-substance: every collapsed checkpoint leaves a one-line record time, author, diff, message in an append-only archive under .memgit/logs/archive/ that gc never touches. Benchmark on a 2,000-checkpoint store: 94% smaller 39.5 MB → 2.2 MB , fsck clean. History operations stay O 1 as the chain grows SHA resolution and checkpoint counting measured at ~0.08 ms at 2,000 checkpoints . All writes go through a git-style store lock 0.08 ms overhead , so concurrent agents can't corrupt the store or lose each other's updates. Two patterns: Shared thread — agents write concurrently; if one commits while another has work staged, the second commit auto-merges three-way, against the recorded base instead of clobbering. Set MEMGIT AUTHOR=agent-name so each checkpoint says who did it. Thread per agent — isolate, then integrate: memgit thread create agent-1 branch off for each agent ... agents work on their own threads ... memgit merge agent-1 three-way merge back common-ancestor based Conflicts same memory changed on both sides resolve to the newest version; an edit always beats a delete. Both histories are preserved. Once registered via MCP, every AI tool gets 6 tools: | Tool | When the AI uses it | |---|---| | resume session | When the request depends on prior state — "continue", "the pending tasks", session start | | search memories | Before answering anything that touches past work or preferences | | get memory | When it needs full details of a specific memory | | list memories | To browse or audit what's stored | | save memory | When it learns something worth keeping for next time | | get checkpoint log | To check when memories were last synced | The tool descriptions teach the AI judgment — "does this request depend on state you don't have in context?" — rather than keyword triggers. Measured cost of the whole tool surface: ~1,150 tokens once per session; a resume session reply is ~335. A save that arrives damaged is refused, not stored v0.13.0 . A model sometimes closes a value with a tag named after the field </rule , and the host then delivers the next parameters inside that value: why , when , tags and type code never arrive, and the memory is stored with defaults. On one machine that was 748 of 3,025 saves. save memory now refuses any value carrying tool-call markup, names the field and the parameters it swallowed, and the model retries in the same turn. Markup quoted on purpose inside backticks is allowed. Every successful save echoes the length of each field it stored, which fields arrived empty, and which values came from a default. Damaged memories already in a store are never served back into context: the digest, the recall hook and read results show each field cut at the damage. memgit doctor counts them, and memgit doctor --repair-markup splits them back into their fields. 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/ — 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. The local engine, the store, the MCP server and every command below are MIT and never gated. Pro is the hosted layer for people who work on more than one machine or with a team: end-to-end-encrypted sync where the server stores ciphertext only, unlocked by one licence key. memgit pro activate <key validate the key with Polar and store it mode 0600 memgit pro status Free / Pro, last verification, expiry memgit pro deactivate remove the key from this machine - Buy a key at memgit.dev/ pricing https://memgit.dev/ pricing — $12/month or $99/year, billed by Polar merchant of record, taxes handled . The key arrives by email and in your Polar purchases page. - The only bytes that leave your machine are the key and memgit's public organisation id, sent to Polar's validation endpoint. No memory content is ever sent. - Headless hosts: set MEMGIT LICENSE KEY=<key in the MCP server's environment; it is validated with the same cache and never written to disk. - Fail-open: a key that verified in the last 14 days keeps working offline; a rejected key drops to Free with a clear message. A lapsed plan never locks your data — reads, pulls and exports keep working. - If this store is logged in to memgit cloud, pro activate also upgrades that account. memgit cloud signup creates your account, a personal team and repo, links this store and turns sync on memgit cloud login on another machine: links to the same repo and turns sync on memgit cloud team invite personal a link for a teammate; they run memgit cloud team join <link 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: 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. memgit's premise is that the AI is the operator — but backup used to require a human to remember memgit git init --remote <url and keep pushing. On this project's own store that meant 1,734 memories on one disk with no copy anywhere, five weeks in. A maintenance task that needs a human command is a task that will not happen. Since 0.9.0 it runs itself, at the end of a session, with the safety boundary drawn at network egress rather than effort : - Local destinations are automatic — a cloud-synced folder you already have iCloud, Dropbox, Google Drive, OneDrive or an external volume. memgit copies files; it opens no connection and signs up for no service. Your existing sync client does the rest. - A git remote is pushed to only if you already configured one. memgit never invents a remote, never creates a repository, and never sends memories to a host you did not choose — memories can contain credentials, and convenience is not a reason to publish them somewhere you never picked. The backup is a single memgit-store.tar.gz , not a directory tree: a 203 MB store is 10,295 small object files, and giving a sync client 10k files to reconcile every time is how you get a sync client that never finishes. It is staged and renamed atomically, keeping the old copy until the new one lands — an interrupted backup must never leave a corrupt file where a good one used to be. memgit backup status where the last copy went, and what else is available 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. Measured across 289 real sessions: injected recall reached ~59% of them, but only 6.8% ever ran an active search — the injected top-3 reads as "memory consulted", so the model never learns there's a queryable store behind it. 0.6.0 makes the passive layer advertise what the active layer knows: - Memory index — the resume digest ends with tag→count pairs 8a8f4ec 6 · instagram 5 and the exact call to go deeper. Counts are truthful: superseded memories are excluded, and every advertised topic is guaranteed to return search results. - "+N more" recall hints — when the per-prompt recall block has more on-topic memories behind it, it says so, with the one call to get them. - Context-triggered recall — a PostToolUse hook: reading a file whose path matches a memory tag surfaces memgit: 6 memories tagged 'x' relate to this path . Reads only a commit-time tagmap cache never the store , capped 3/session. - Trackers tr — one memory per in-flight entity <entity -status , updated by re-saving the same slug. They render as a status board at the top of every session: memgit is the authority for entity status; files may lag. - Supersession — a correction names what it replaces supersedes= old-slug instead of a "CORRECTED:" prefix. Superseded memories vanish from search/recall/resume history preserved; list still shows them marked ⊘ , so injected context is never stale. 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, --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 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 memgit remove <slug aliases: delete, rm, del — mistypes get a "did you mean?" Core operating guide — per-project, always-on, cross-host memgit core seed draft a guide from this project's skills + rule files 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 Durability — automatic, no human command required memgit backup status last copy, staleness, available destinations memgit backup now force one immediately memgit backup set <path pin a destination memgit backup off / on control the automatic path 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 + stale session caches memgit stats measured context costs + disk usage memgit doctor hygiene + scope losses: split labels, quarantined, stale caches, orphaned usage memgit doctor --audit every split and stranded label, the save landing rate, throughput memgit doctor --audit --json the same report as JSON memgit doctor --relabel map.json bulk re-project memories {"slug": "Label" | ""} ; one checkpoint memgit doctor --repair-markup dry run: memories whose fields swallowed other parameters on save memgit doctor --repair-markup --yes --project LABEL split them back into their fields; one checkpoint memgit lint validate all memories flags unknown provenance memgit fsck verify store integrity Import / export memgit sync sync from Claude Code files + commit auto-finds them memgit import claude-code path path optional — defaults to ~/.claude/projects/ /memory memgit import file <path memgit export <slug Git sync team features memgit git init --remote URL memgit git push remote branch memgit git pull remote branch memgit git export memgit git status AI tool registration memgit setup interactive step-by-step picker memgit setup all auto-register every detected tool memgit setup claude-code memgit setup cursor memgit setup windsurf memgit setup cline memgit setup continue memgit setup gemini-cli memgit setup hooks Claude Code hooks: resume at start, per-prompt recall, 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 memgit pro status / deactivate Server memgit serve MCP stdio Claude Code, Cursor, Windsurf, Cline memgit serve --http HTTP REST ChatGPT Custom Actions, Gemini Visualization memgit graph D3.js interactive relationship map memgit thread list / switch / create | Tool | Protocol | Command | |---|---|---| | Claude Code | MCP stdio | memgit setup claude-code | | Claude Desktop | MCP stdio | memgit setup claude-desktop | | Cursor | MCP stdio | memgit setup cursor | | 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 | memgit runs inside your agent, so the honest answer to "what does this process read from my environment?" should be checkable rather than a promise. The table below is generated from memgit/env.py https://github.com/code4161/memgit/blob/main/memgit/env.py , and tests/test env inventory.py walks the package on every test run and fails if the code reads a name this list does not carry — or carries a name nothing reads. The list cannot drift away from the code. memgit reads these and nothing else. It writes none of them. None of them turn network access on: the cloud endpoints are overrides for a sync you have already opted into with memgit cloud login , and with no licence and no cloud login, memgit talks to nothing. | | Variable | What memgit does with it | |---|---|---| | Store and state | MEMGIT STORE | Absolute path to the memory store. When set it is the ONLY candidate — an explicit store never silently falls back to another one. | | | MEMGIT HOME | Base directory for memgit's per-person state, currently the licence file default ~/.memgit, mode 0600 . | | | MEMGIT PROJECT | Forces the project label instead of detecting it from the working directory. | | Attribution | MEMGIT AUTHOR | Explicit author stamped on checkpoints, for multi-agent jobs where several writers share one machine account. Wins over MEMGIT CLIENT. | | | MEMGIT CLIENT | The host that launched this process claude-code, cursor, ... , stamped into checkpoints so a memory says where it came from. | | | USER | Fallback author name when neither MEMGIT AUTHOR nor MEMGIT CLIENT is set. | | | USERNAME | Windows fallback for USER. | | Licensing memgit Pro | MEMGIT LICENSE KEY | memgit Pro licence key. Never printed in full — memgit pro status shows the last four characters. | | | MEMGIT POLAR API | Overrides the licence-validation API base URL testing . | | | MEMGIT POLAR ORG ID | Overrides the Polar organisation the licence is checked against. | | 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. | | | MEMGIT NO SYNC HINT | Set to 1/true/yes to never show the one-line memgit cloud offer in the session digest and after export or backup. The offer is decided from the store alone and sends nothing. | | 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. | | Set by other software | CLAUDE PROJECT DIR | Set by Claude Code for hook processes; used as one input to project detection when the working directory is not the project root. | | | PYTEST CURRENT TEST | Set by pytest. Its presence suppresses automatic backups, so a test run never writes into a real backup location. | Memories are project-scoped, so a wrong label files a memory where you will not find it again. The label comes from the first of these that yields one, and there is exactly one detection path shared by the MCP server, the CLI and the hooks — so a label derived at save time and one derived at recall time cannot disagree: 1. MEMGIT PROJECT — a forced label, taken verbatim 2. the cwd a host reports in its hook payload the real workspace, even when the process working directory is elsewhere 3. CLAUDE PROJECT DIR 4. the process working directory The label keeps A-Za-z0-9- and turns everything else into a dash, exactly as Claude Code names its projects/ directories — including the character, which becomes a dash. Labels written before v0.12.0 kept the ; they are folded onto the dash form when two labels are compared , so nothing written under the old form stops resolving, and nothing stored is rewritten. A project whose memories have split across two labels raises no error anywhere: the save succeeds, fsck stays clean, and the only symptom is an answer that is missing things. memgit doctor reports splits, stranded labels and the save landing rate by default; memgit doctor --audit adds every row. A repair heals toward the label whose directory exists , never toward the one holding more memories. When none of them yields a label — running from $HOME , for instance — a write is quarantined under unknown rather than filed globally, and memgit doctor --relabel moves it once you say where it belongs. Folding a free-text label onto an existing project log-report → Downloads-log-report happens only when the input is a trailing segment of exactly one known label and that label already holds memories; anything ambiguous is left alone, and every fold is reported rather than done silently. Standard markdown memory file: Rule: Never mock the database in tests Type: feedback Priority: medium Why: We got burned last quarter — mocked tests passed but the prod migration failed. When to apply: Any time writing tests that touch persistence layers. Tags: testing, database The same memory in TOON: TOON1|fb|no-db-mock|2026-07-01T10:00Z testing database PROJ:my-app RULE:Never mock the database in tests WHY:Mocked tests passed but prod migration failed last quarter WHEN:Any persistence test BODY:Full long-form detail lives here, losslessly newlines escaped .\nSearch returns the compact RULE; get memory returns everything. Measured with a real tokenizer, TOON is ~5–10% leaner than equivalent markdown — a nice bonus, not the headline. The headline saving is retrieval : memgit loads the top-8 relevant memories per query instead of everything. At 108 memories: 12,840 tokens dump everything → 640 tokens memgit BM25 top-8 For exact token counts in memgit stats , install the optional tokenizer: pip install "memgit tokens " . ~/.claude/memgit-store/ .memgit/ objects/ ← SHA-256 content-addressed blobs gzip compressed refs/threads/main ← HEAD checkpoint SHA TOON INDEX ← active slug→sha mapping config ← author, default thread logs/ ← ref change audit trail memories/ ← flat .toon files git-trackable, human-readable .git/ ← standard git repo after memgit git init git clone https://github.com/code4161/memgit.git cd memgit python -m venv .venv && source .venv/bin/activate pip install -e ". dev " pytest 431 tests, all passing, < 5 seconds See CONTRIBUTING.md https://github.com/code4161/memgit/blob/main/CONTRIBUTING.md . - Content-addressed object store git-identical architecture - TOON format compact line-oriented memory format - MCP server — Claude Code, Cursor, Windsurf, Cline, Continue.dev - HTTP server — ChatGPT Custom Actions, Gemini function calling - BM25 relevance search load only what matters - memgit stats — measured token savings proof - memgit squash — scale to 10k+ sessions - memgit git push/pull — team sync via standard git - Flat memories/ directory — grep/diff/blame your memories - D3.js graph visualization of memory relationships - memgit resume + SessionStart hook — sessions start with "where we left off" - Guardrail hooks — per-prompt auto-recall + end-of-session capture guard v0.4.0 - Core operating guide — per-project, always-on, cross-host, self-improving v0.5.0 - memgit gc — space reclamation mark-and-sweep, lossless squash archive - Multi-agent write safety — store lock, auto-merge commits, memgit merge - PyPI + Homebrew tap + npm published v0.1.5 - Chocolatey — live on community.chocolatey.org choco install memgit - Interactive setup wizard memgit setup - Smart memgit init auto-detects tool, no path needed - Lossless memories — full body alongside the compact rule v0.3.0 - Project-scoped memories + memgit onboard mid-project bootstrap v0.3.0 - VS Code extension v0.1.5, Marketplace: code416-memgit.memgit - Codex + Antigravity support — MCP registration + AGENTS.md core guide v0.8.0 - memgit eval — measured retrieval quality, real + non-circular sets v0.8.0 - Usage-aware ranking — the recall ledger feeds relevance, not just the guide v0.8.0 - Automatic core-guide bootstrap — the self-improving loop starts itself v0.8.0 - Automatic off-machine backup — no human command required v0.9.0 - JetBrains plugin Phase 3 - Semantic search via embeddings — gated on memgit eval showing a real gain Phase 4 - Public benchmark numbers LongMemEval, LoCoMo Phase 4 - memgit.dev website live - Memory compression / auto-summarization Phase 5 - Team access control + audit trail Phase 5 - Memory marketplace — share reusable context packs Phase 6 MIT — see LICENSE https://github.com/code4161/memgit/blob/main/LICENSE .