SessionMunch without an AI summarizer

I want a memory system that can tell me what actually happened before it offers an opinion about what happened.

That sounds like a small requirement. It gets less small when the source material is an agent session: user requests, tools, commands, output, corrections, interrupted work, and a final message that may be cheerfully confident about something the preceding output does not support. Hand all of that to a summarizer and the prose will probably improve. Whether the account improves is a separate question.

This is why SessionMunch has a useful answer to an apparently awkward question: what happens if I don't configure an LLM?

Quite a lot.

Start with evidence

The current implementation preserves supported captured or imported activity as sanitized evidence. Native transcript import feeds a session event ledger, retaining the session's origin and event sequence. Import is idempotent: running it again is intended to converge on the same recorded history rather than manufacture another copy of Tuesday.

There are boundaries. An adapter can only read what its harness exposes. Sanitization changes the material being retained. Large imported payloads use bounded inline excerpts, with full sanitized content kept separately as content-addressed artifacts. An inline search result therefore need not be the whole event.

I want these distinctions visible. A memory system that quietly substitutes “the bit we kept” for “everything that happened” has already started writing fiction.

A session card does not need a chat model

When a session has imported or managed transcript events, SessionMunch builds a deterministic Markdown session card. It extracts requests, observed tool work, commands and their observed exit status, checks, commits, files touched, and the final substantive assistant response.

The useful word there is “observed.” A command appearing in a transcript does not establish that it passed. A tool call without a paired result leaves a gap. The digest carries those limits rather than filling them with a reassuring adjective.

Each extracted item points back to event references such as e17. Those are ledger sequence numbers, so the reference still names the same event as the session grows. The card is navigation over evidence. It isn't a replacement for the evidence.

There are practical limits here too. Cards are bounded. Long final replies are visibly clipped, and very long sessions can produce cards from their latest transcript events with the coverage limit stated. Hook mirrors are excluded from the transcript-card input, avoiding a second account of activity already present in an imported transcript.

Sessions with only the older observation-style material take the rule-based observation-summary path. Those summaries are terser. I would rather explain the difference than pretend every old session magically acquired a complete transcript.

I want the memory to admit what it missed before it tells me what it means.

A true session-end event can write the card. Imported sessions that never emit that event can be picked up by bounded maintenance. That matters because importing history and ending a live session are different operations; the importer shouldn't have to impersonate a departing agent to make the history readable.

Where AI becomes useful

With a provider configured, the optional AI summary adds a separately labelled interpretation to the card: outcome, decisions, retractions, and a next step. It names the model and cites source events. Validation checks the citations and rejects certain contradictions; it does not turn generated prose into a proof.

The deterministic account stays above it. I can inspect the interpretation and follow its references instead of accepting a polished paragraph as the only surviving witness.

Consolidation has another job: turning session material into durable knowledge such as decisions, gotchas, and procedures. That is where a generative model can earn its electricity. It can identify the rule hiding inside repeated debugging work. I still want the original evidence available when the rule looks suspicious.

“No LLM” and “no inference” are different settings

Embeddings are also models. They convert text into vectors for similarity search; they don't write the session account. SessionMunch can use local embeddings without a generative summarizer.

If I want no model inference at all, I disable embeddings as well. Lexical search, entity matches, and link relationships still provide retrieval. Plain Markdown knowledge remains inspectable, and its derived search index can be rebuilt.

That last sentence needs care. Reindexing the wiki does not recreate every raw event or separate artifact. The ledger and artifact storage are their own backup concern. Owning readable knowledge is valuable; confusing it with a complete backup would be expensive.

SessionMunch is a v0.1.0 release candidate. The reason I care about this architecture now is simple: I want to stop reexplaining projects without making continued access to my own history depend on a particular model being awake.

Back to the SessionMunch series.

Sources and setup

Implementation references pinned to the revision used for this article: architecture, deterministic digest, session cards, and native import. Start with the public quick start.