Not a filing cabinet. A product, mapped.

Compression is proven lossless — saved bytes are real, recoverable, and audited.

classify → rank → dedupe → fit → summarize, in one deterministic pass.

Commands are rewritten so compressed output is the only version cached.

Structured compressors for git, docker, npm, pip, cargo, terraform.

Compression that does not invalidate the model's prompt cache.

Multi-chunk recovery and GC that never deletes a live session's output.

Token-weighted savings that refuse to double-count or inflate.

Reversible extractive compression for docs and memory files.

Typed, approved facts — decisions, bugs, gotchas, conventions — recalled across sessions.

Agents suggest, a human approves. Nothing enters recall unvetted.

Hybrid BM25 + embeddings find the right memory, not just keyword hits.

See how memories connect, conflict, and supersede each other.

Your brain follows you across machines, E2E-encrypted to your own S3.

One command explains your brain's health and points at the exact repair.

Every session boots with a budgeted brief assembled from the project brain.

Agent-written memories must resolve evidence before they persist.

Evidence-backed hybrid recall — the benchmark runtime, now the product.

Files split on function/class boundaries, so the model sees whole coherent units.

Signatures first, bodies on demand — lossless and additive.

Re-reading an unchanged file returns a pointer, not the file again.

Never re-send what's already in the context window.

Compression keeps the lines about your current task, not generic ones.

A freeloader table showing which injected memories and rules actually earn their place.

Typed code blocks so retrieval works on blocks, not files.

Secrets are stripped before anything is stored — the invariant the whole product rests on.

Home credential stores and private keys never reach the model.

Blocked secret reads and PII redactions, with an auditable leak ledger.

Regexes that cannot hang on pathological input, proven by a growth-ratio harness.

Path-glob matching rebuilt on an NFA matcher — no regex injection.

Tighten-only command and path allow-lists at the project boundary.

Pasted content is held and inspected before it can act on your repo.

“Done” is joined to the actual exec receipt — no unverified success claims.

Blocks imports of packages that don't exist before they waste a session.

Surfaces failures that would otherwise vanish into the log.

Receipts prove a review covered the code that actually shipped.

Claims about code are checked against the code itself.

Proves a test actually catches the bug it claims to cover.

Past mistakes become rules that block repeats before they happen.

Pack live task state and hand it to another agent mid-session.

A dead session's working context is rebuilt into a bounded kickoff capsule.

After compaction, the agent is reconnected to what it still needs.

A bounded, safe kickoff brief for every task — nothing more, nothing less.

Snapshot a conversation and resume from a pending capsule.

Live presence, messaging, and claims across parallel agents in one repo.

Roster, roles, task queues, and a live board for many agents.

Post, resolve, and promote facts on a shared board.

Agents ask each other — rate-limited and keyword-hinted.

Advisory nudges keep a session from running away.

Decompose a task into a tracked, retryable plan with selective retry.

A windowed, persisted token-savings summary — your running receipt.

Spend and savings receipts by project, task, agent, and session.

See why each context happened — the causal chain behind every output.

See which files and outputs burn the most tokens.

One command explains the raw-vs-delivered gap for the last failure.

Honest report of output that bypassed the saver, grouped by cause.

History, insights, forecast, and share cards — with CSV/JSON export.

Median+MAD spike detection and persistent savings goals.

Per-session and per-task token limits with warn-only alarms.

Transparent token metering — counts only, on loopback, opt-in.

A dedicated supervisor keeps the proxy up without EADDRINUSE crash-loops.

Routing through the proxy no longer taxes the prompt cache.

The localhost dashboard served by mega gui — no clone, no build.

A live-first dashboard over running Claude Code sessions.

Install and repair the bridge and connector blocks in one click.

Dashboard numbers wired to real ledgers — it stops lying.

Sidebar shell and amber editorial — a calmer, clearer console.

Hooks, MCP bridge, and the dashboard in a single mega init.

Activate everything idempotently, with manifest-backed reversal.

Instruction blocks for Claude Code, Codex, Cursor, and Aider — your content preserved.

Native tool output compressed automatically via a PostToolUse hook.

35+ tools over stdio, each publishing a real Zod input schema.

Audits your MCP config for clones, shadowing, and non-localhost URLs.

Protects generated files, lockfiles, and build output from agent edits.

Discover, install, and load agent skills — with path-escape guards.

The agent-agnostic engine — agents connect to it, never the reverse.

The redact → chunk → rank → fit → summarize pipeline, as its own package.

Full win32 store path, CRLF-safe writes, and a Windows CI matrix.

A committed write never fails on a post-rename fsync error.

One durable atomic-JSON-store mechanic, shared by every package.

The repo skeleton and the agent governance files that dogfood the product.

A daemonless lazy worker, so the standalone bundle stays lean.