The Zero-Daemon Memory Engine: How We Truncate 10,000 Lines of Code into 40 Tokens

Every time an AI coding harness launches a heavy background language server, an angel loses its wings.

In 2026, the standard enterprise recipe for giving an AI coding agent repository awareness is remarkably uninspired: spin up a 2GB Java or Node.js Language Server Protocol (LSP) daemon, launch a background vector database with chunked embeddings, and dump tens of thousands of tokens of raw code into the context window whenever the agent asks where a function lives.

In Yusuf’s digital workshop, that entire paradigm is treated as an architectural crime.

When you pair with autonomous agents at 3 AM across multi-repository workspaces like citation-manager, boun-archive, and hepyeni, background daemons die silently, vector embeddings hallucinate semantic similarity when you actually need topological connectivity, and bloated whole-file dumps drown the model’s reasoning in token noise.

Enter mimori: our zero-daemon project memory, AST repository mapping, and session activity engine.

1. Embeddings Are Not Architecture

Vector databases are great when you want to find “code that feels like a payment processor”. They are disastrously incompetent when you want to know:

“If I change the signature of authMiddleware in server/middleware.ts, which 8 routes break, what imports them, and what does the call-graph look like?”

Embeddings compute cosine distance between token clusters; they have zero concept of topological in-degree or import graphs.

When an agent needs orientation in a codebase with 58 files and 10,725 lines of parsed code, it doesn’t need to read every line. It needs a structural radar.

`server/db.ts` · 189 ln · ← admin, api.test, auth, citations, +8 · 3 commits/90d
  :6    export const db = new Database(dbPath, { create: true });
  :15   export function initDB()
  :168  export function resetDB()

Look at that single line: ← admin, api.test, auth, citations, +8. That arrow is the one crucial insight that a raw grep or embedding search cannot give you in a single step: who depends on this file.

2. PageRank + 90-Day Git Churn: How the Radar Works

Instead of running a resident daemon that consumes memory and risks stale cache states, mimori runs entirely on-demand as a zero-daemon binary. When a session boots, it runs:

mimori dump > /tmp/ctx.md

Under the hood, it doesn’t just list files alphabetically. It builds an in-memory directed graph of the repository’s imports, combines it with git commit frequency over the last 90 days, and runs a PageRank algorithm weighted by entry-point heuristics.

1. In-Degree Ranking: Modules imported by everything (server/db.ts, AuthContext.tsx) bubble to the top of the map.
2. Churn Weighting: Files that were edited 15 minutes ago or modified across the last 3 commits get prioritized over dusty static configs.
3. Budget Compression: It spends approximately ~40 tokens per file. A 10,000-line repository is compressed into an orientation snapshot that fits comfortably in a fraction of the agent’s context budget.
4. Degradation by Priority: If the character budget binds, low-ranked leaf nodes collapse cleanly into directory summaries (dev-docs/ — 9 files (.md)), leaving high-impact architectural nodes fully exposed with their exact line numbers.

3. Caveman Style: Stripping the Connective Slop

The second pillar of our memory engine is how agents record persistent knowledge. Traditional documentation is bloated with polite corporate filler:

“It might be worth considering that during test execution, one should probably ensure the SQLite database is kept in memory to prevent concurrency collisions…”

In .mimori/memory.md and .mimori/decisions.md, that entire paragraph is outlawed. We enforce Caveman Style:

## [2026-08-23] Test Suite Architecture & Isolation
- **Context**: Tests shared prod DB and global state; concurrency caused data leaks.
- **Decision**: Force `:memory:` SQLite during test runs; wipe DB beforeEach. Bootstrap vitest + RTL.
- **Consequences**: Tests run in parallel cleanly. Strict structural and status assertions required.

• Drop: Articles (a/an/the), filler (just, really, basically, simply), hedging (“it might be worth”), connective fluff (furthermore, additionally).
• Keep Exact: Code identifiers, file paths, commands, HTTP status codes, error strings.
• Rule: Never drop not/never/no/only—flipping polarity costs infinitely more than saving one token.

When a fresh subagent boots up, it reads the caveman ADRs and invariants in under 300 tokens and immediately knows the sacred rules of the system without having to discover them through 3 failed test runs.

4. Compute, Don’t Read

The overarching rule of the workshop is simple: Think in code — compute, don’t read.

Never pull 20 files into context to count how many routes require admin privileges. Write a one-line bash or python script, execute it, pipe the answer to stdout, and let the agent see only the result:

rg -c "adminMiddleware" server/routes | awk -F: '{s+=$2} END{print s}'

When you treat repository structure as a mathematical graph rather than an endless stream of text, agents stop hallucinating, context windows stay crisp, and you can refactor entire production backends at 3 AM with zero jank and zero wasted tokens.