Open source · MIT DeepSeek Harness plugin One YAML patch to mount Typecheck-clean · smoke-green A subclass of the harness's own engine v0.2 · the rebase

The memory seam · one session, forever

MOLT

The memory loom for your DeepSeek Harness sessions. At the pressure you set — default 80%, your hysteresis — MOLT folds the oldest history into mini-summaries that carry pointers to the lossless tape: never touching your recent turns, never deleting a byte. A session that never has to die, and never has to lie about what it forgot.

Mount it · one patch ↗ Sibling: TOWER → The harness ↗ ← AORTA

FREE FOREVER. NO ACCOUNT, NO CLOUD, NO TELEMETRY. NOTHING LEAVES THIS MACHINE — THE TAPE IS THE SESSION'S OWN LOG, AND THE FOLD ONLY SHADOWS IT. THIS PAGE MAKES ZERO NETWORK REQUESTS, LIKE THE PRODUCT.

BUILT FOR HARNESS — THE "EVERYTHING IS A PLUGIN" AGENT RUNTIME · MIT ↗

§ 01

Compaction freed your context. Restarting freed it better — by throwing it away.

Day four of the refactor. The session is at 94% and you have two honest choices: let auto-compaction summarize everything — recent turns included, exact words gone — or restart, paste the handoff doc, and spend the first hour re-explaining the thing you were just holding in your head. Both options cost the same thing: the working context you paid for.

Your machine · one session · 11:02 PM

The session knows the decision from day one, the three constraints you added at 4 PM, and the exact command that fixed the linker yesterday. It just hit its window, so tomorrow it will know none of that verbatim — it will know a summary of a summary of it. The tape with the real bytes is on disk. Nothing is reading it.

You are the memory system now — for a machine whose only job is to remember the conversation it is in. The bottleneck in your longest session is that its memory has no pointer, only prose.

Why is your longest session the one you restart?

The bytes were never lost — they're in the append-only log. What's missing is the fold: the move that removes them from the window, leaves a summary and a pointer in their place, and keeps the recent turns byte-for-byte. MOLT is that fold, mounted as one plugin, firing on its own at the pressure you set.

§ 02

A fold, not a summary. A pointer, not a copy.

MOLT writes no content and invents no memory. It is a watchdog: it prices the session's surface every closed turn, and when occupancy crosses your threshold it folds the oldest shadowable band — at a safe seam, at the quiet barrier — into a checkpoint whose pointer resolves to where the real bytes still are.

Folds

At the pressure you set — default 80%, your hysteresis. Oldest-first, never mid-turn, never across an open tool chain, never into the founding turn or the last N turns.

Points

The checkpoint carries a pointer token; the loom injects its resolution — id → seqs A–B · sha256 — one line later. The bytes stay in the log forever.

Indexes

Each fold appends a mini-summary to a persistent, session-scoped index — so the session accumulates memory instead of thinning a single blob.

Why a summary alone is a lie — the pointer law Prose about prose about prose is a compression death spiral: each cycle invents a little, loses a little, and after enough cycles the summary resembles nothing that was ever said. A pointer cannot confabulate — it either resolves to the bytes or fails loudly. Above the tape, a gist and a down-pointer, never a copy. Structure proposes, text disposes. And because the harness derives history from the log on every request, a fold takes effect on the next request — no reload wall, no restart, no archive dance.

One seam, one engine MOLT is not a second compactor racing the harness's own. It is the engine — a subclass of DeepSeek Harness's shipped compaction backend, inheriting its pressure math, balanced cuts, overflow recovery, and locks, and overriding exactly one hook: what the checkpoint says. Mount it instead of the default engine, and the harness's own duplicate-service refusal is the coexistence guard.

What the harness already gives you — and what MOLT adds.

The subclass story makes this comparison safe to publish: MOLT is not a competitor to the shipped engine, it is the shipped engine plus the honesty layer.

Concern	Shipped engine (compaction-basic)	MOLT (this plugin)
Pressure & trigger	Token-meter pressure, routed capacity, overflow recovery	Inherited, untouched
Selection & seams	Balanced tool-pair cuts, retention tail, convergence retries	Inherited, untouched
Checkpoint content	One LLM summary over the whole region	Banded summaries at graded levels — or pure pointers, no prose at all
Pointer to the bytes	—	Every fold: pointer token + injected resolution (id → seqs · sha256)
Read-back	—	memory_read: exact bytes back, raw mode + recomputed hash
The fence	—	Needles verified byte-for-byte; unquotable → fold refused, graceful degradation
Receipts	—	MEMORY_RECEIPT v1: one append-only line per fold, sha256-ground
Memory index	—	Session-scoped index + memory_recall
Instrument panel	—	molt_status + /molt (the fold as a command)

§ 03

Tape. Fold. Needle. The three-layer memory model.

Everything a session has ever done exists three times: the tape — the append-only log, byte-exact, forever; the fold — the lossy checkpoint in the window, wearing its fidelity on its face; and the needle — the load-bearing facts that must survive, verified byte-for-byte. Every memory system ever shipped keeps only the middle one. The trust lives in the disagreements.

Tape"…and never delete the fixtures directory." — seqs 218–241, sha256 9f3c…e1, still on disk

Foldband 2/4 · L2 · msgs 12–31 — five-field summary + pointer; the loom injects id → seqs 218–241 · sha256

Needle"never delete the fixtures directory" — quoted verbatim from the band, byte-checked against the tape

VerdictFOLDED — summary in the window, pointer resolvable, needle carried verbatim, receipt appended.

Three layers, one memory. Auto-compaction sees only the middle — MOLT holds all three, and their disagreements are the product.

Fold ⊕ Tape — the pointer gap

A checkpoint that summarizes without naming where the bytes live is amnesia with a cover story. MOLT's pointers resolve through memory_recall/memory_read — exact text back, hash recomputed, or the resolution refuses.

Needle ⊕ Fold — the unquotable needle

The planner claims a line must survive; the fence checks it byte-for-byte against the band. An unquotable needle refuses the whole fold — and the harness's own failure law degrades gracefully to full history. Fail-safe, never silently over-strict.

Tape alone — the exact words, day forty

Forty days in, you need the exact command from day two. Not its gist — its bytes. The pointer is one tool call away. That is the entire difference between a session that remembers and one that paraphrases.

# ten seconds, on the real seams — the fold, then the read-back 10:04:12 [molt] fold at 80% · band 2/4 → L2 · msgs 12–31 · safe seam · quiet barrier 10:04:12 [molt] pointer token in checkpoint · resolution injected: ptr 9f3c… → seqs 218–241 10:04:12 [molt] receipt appended · MEMORY_RECEIPT v1 · sha256 9f3c…e1 10:04:13 > memory_read seqStart 218 seqEnd 241 10:04:13 9 events · sha256 9f3c…e1 ✓ · text follows 10:04:13 "…and never delete the fixtures directory."

Static transcript, honest labels: the fold and the read-back are the product's ten seconds.

§ 04

What only a folding session can see.

A session with no folds is blind past its window; a session with dumb folds is blind inside its window. The catches below require holding the tape plus the folds plus the refusals at once — which is exactly what no plain summarizer does:

The forgotten refusal

You said no to this twenty minutes ago. The context compacted; it forgot your refusal. Pin the refusal as a needle and no fold may ever pass without carrying it verbatim. A catch that gets stronger as sessions age — exactly when sessions get weaker.

The resumed thread

The session resumes from the log; checkpoints merge; the index of mini-summaries survives restart. Day two's decision is one recall away on day four — not because the model remembered, because the loom did.

The tampered tape

Every fold appends a receipt — compaction id, span, shadowed seqs, sha256. Recompute the hash and it doesn't match? A finding, not a shrug. The memory wears its receipts on the outside.

Why the honesty layer is the gap The harness already ships the fold — the pressure math, the balanced cuts, the overflow recovery — under MIT, and MOLT is a subclass of it, not a rival. What nobody ships is the honesty layer: the pointer to the exact bytes, the byte-for-byte fence, the receipts on everything. The fold was never the gap. What the fold refuses to claim — that's the gap. On your machine, with your log, closing it is one patch.

§ 05

The loom: one session, one glass.

Today your session's memory lives in its context and nowhere else. The loom is one surface — occupancy, the fold history, the index — plus the one command that ends the ritual:

MOLT · THE LOOMIllustrative — not telemetry1 session · 4 folds · 1 tape

occupancy · window 128k80% → FOLDthreshold 80 · retain 16% · last fold freed 1,842 tok, 2 turns ago

band 2/4 · msgs 12–31L2ptr 9f3c… → seqs 218–241 · sha256 injected · recall ×2

band 1/4 · msgs 0–11L1 · IMMUNEfounding decision + the fixtures refusal · never descends

band 3/4 · msgs 32–44STUBpointer only, no prose — the floor, by design

tape append-only · 0 bytes deleted · ⚠ recent turns: byte-identical, never folded
receipts 4 · index 4 entries · last read-back hash match ✓

when you decide, not when the window does: /molt — fold now, through the engine. Deterministic. ~milliseconds. The fold is a command, never a conversation.

One glance where there was a ritual — and the bottom line is the whole thesis: the bytes were computed; the fold is the label. The panel is an illustration; the tools behind it are real and registered.

Every fold, every refusal, every read-back lands in the ledger as a labeled record — yours, on your disk, forever. That record is how a session earns the rungs below.

§ 06

The descent: L1 → L4 → STUB → the tape.

Memory compresses like a Poincaré disk — recent at full resolution, ancient at a glance, nothing ever falling off the edge. Bands descend with age and pressure, and every descent is earned by the ledger of the level above it — never skipped to:

The memory. v0.2.1 · bench-doubled

Rich five-field summary — what happened, what changed, what matters, what's unresolved, anchors. The newest band, the founding band, the immune band.

L2 · L3

The digest. v0.2.1 · bench-doubled

Episode-grade: broad strokes, anchors, still a summary — now smaller, with the pointer carrying what the prose elides.

The tag. v0.2.1 · bench-doubled

One line, anchors only. The oldest material, still addressable, still recallable.

STUB

The pointer. v0.2.0 · live-measured

No prose at all. A span and a hash. The deterministic floor — cutter mode — the fold that cannot confabulate because it contains no generation.

DREAM

The re-reader. The aspiration

At idle, the loom re-reads one old band nobody has recalled in a while — looking where nothing pointed — and either refreshes its entry or demotes it honestly. Anti-drift by schedule, not by hope. This rung is not a feature; it's a threshold: it ships only after the measured recall curve says the descent needs a guard, and the number is the case for it. Until the number exists, this paragraph stays labeled what it is.

The memory doesn't disappear. It descends — from the window, to the tag, to the pointer, to the tape. The last rung is the tape, and the tape never forgets.

§ 07 Designed

A summarizer doesn't have to be smart. It has to be honest.

The judgment tier's job was never to be the genius — it's to decide what a band deserves: prose, a tag, or nothing but a pointer. The work splits two ways:

The floor — deterministic, always

Zero LLM. Safe seams, pinned turns, STUB bands, byte-verified needles, receipts. Runs in milliseconds and can never hallucinate, because it never generates. This layer never sleeps and never lies.

The planner — yours, optional

Bring your own key — one fused call grades each band: level, five-field summary, anchors, needles. Any failure, any invalid plan, any unquotable needle: the floor takes over, and the fold still lands. The intelligence is rented by the call; the memory can't be rented at all.

That division is the whole answer to "is the summarizer smart enough to be trusted": the summary is a proposal; the fence is bytes; the tape is the floor under both.

§ 08

The fence: model-free, byte-for-byte, always on.

Beneath every learned judgment sits a deterministic fence that asks no model's opinion:

The needle check

Every claimed load-bearing line is searched byte-for-byte in the band. A needle the planner invented but cannot quote refuses the fold — structure proposes, text disposes.

The safe seam

The cut never splits a tool call from its result, never lands mid-turn, never crosses an open tool chain. The quiet barrier is mechanical, not advisory.

The pinned turns

The founding turn and the last N turns are byte-identical before and after every fold — pinned by construction, asserted by test.

The receipts

One append-only line per fold: span, shadowed seqs, sha256, band count. A memory that can be audited is a memory that can be trusted.

Floor proposes, planner grades, fence disposes. And the deepest fence isn't any model's judgment — it's the append-only log itself, which no fold can rewrite: nothing is ever deleted, only shadowed.

§ 09

The loom's own rules.

MOLT will never

Delete a byte of the log. It shadows and points. The tape is the tape; reversal is a read, not a restore.
Touch your recent turns or your founding context. The working memory and the identity are pinned, byte-for-byte, forever.
Summarize when a pointer will do. The deterministic floor runs first; prose is a proposal the floor can always refuse.
Fire mid-turn or across an open tool chain. The fold waits for the quiet barrier, or it doesn't happen.
Claim a fold it can't prove. Every fold leaves a receipt with a recomputable hash. A mismatched receipt is a finding.
Race the harness's own compactor. One seam, one engine — mount it instead, never beside; the duplicate-service refusal is the guard.

And the boundary that runs the other way: you can fold whenever you want — /molt is a command, not a permission — and every fold is a labeled record you own, on a disk you control.

§ 10

Built for the longest session you own.

The ledger

Append-only receipts, one per fold, hash-grounded — the same contract the estate's concordance already folds. When someone asks "what did this session know, and what happened to the rest" — the answer is a file, not a memory.

The metric

Not summarizer quality. Hours between restarts, and recall latency for exact bytes — both computed from the receipts from day one. "One session ran for a month and could still quote day two" converts to product without a story.

§ 11 Measured — the smoke

The plate.

MOLT is verified against the harness's own machinery. These are the current receipts — measured, dated, run on this machine's checkout:

Quantity	Rating	Receipt
Typecheck against the harness's published types	0 errors	tsc --noEmit, 2026-08-20
Test suite (pure + live harness-boot smokes)	14 / 14	vitest, 2026-08-20
F-TWICE — two folds, one session, disjoint shadows	green	real agent-loop dispatch
Fence refusal → graceful degradation	30/30 turns	unquotable needle, live
Read-back hash parity (tape commitment recomputes)	exact	memory_read raw, live
Receipt parity (fold line matches index)	exact	MEMORY_RECEIPT v1
/molt manual fold through the command registry	green	compactNow, real dispatch
Planner tier: graded bands, verbatim needles	green	scripted planner double

REFERENCE BENCH: REAL HARNESS BOOT IN-PROCESS (SESSION STORE, TOKEN-METER, AGENT LOOP, COMMAND REGISTRY, MOCK ADAPTER). THE PLANNER'S MEASURED TAG COVERS A SCRIPTED DOUBLE, NOT A LIVE MODEL — THE LADDER SAYS SO ON ITS RUNGS. PRODUCTION NUMBERS DO NOT EXIST YET AND THIS PAGE WILL NOT PRETEND THEY DO. THE LIVE WEB-PROFILE MOUNT AND A REAL MODEL EXERCISING RECALL/READ-BACK ARE THE REMAINING BET-TO-MEASURED STEPS, AND THEY WEAR THEIR TAGS UNTIL THE TAPE SAYS OTHERWISE.

On the DeepSeek Harness substrate

MOLT is a fit: the pointer-and-fence memory discipline pointed at the one harness whose history is already derived from an append-only log — deepseek-harness, the "everything is a plugin" agent runtime. The estate's other fits — TOWER (your agents) and PROMPTER (your meetings) — live at opnaorta.ai.

§ 12

Free. Yours. Read the source before you mount it — that's the point.

In a plugin that folds your session's memory, "trust us" is not an installer. MOLT is MIT-licensed TypeScript you read, typecheck against the harness's own types, and mount with one patch — on the machine it remembers for.

# what it takes Harness DeepSeek Harness (dsh) — pin a commit; it's a dev preview Mount one profile patch, instead of the default compaction engine: - id: molt2 name: '@bo/dsh-molt2' config: { basic: { thresholdRatio: 0.8 }, maxBands: 6, needles: ["never delete the fixtures directory"] } Tools molt_status · memory_recall · memory_read · /molt # /molt folds now, through the engine; the others are the panel, # the index, and the read-back. All four are registered and tested. Planner optional: your own provider/model — one fused call per fold; empty = pure pointer mode (cutter floor, zero LLM) Verify pnpm exec tsc --noEmit && pnpm test — 14 receipts and counting Runs as two plugins: the engine (a subclass of the shipped backend) + the event-driven archivist. One seam, one engine. Network none required. The tape is your session log; the index is a file. # get it git clone <the lane's repo> # C:\WTF\dsh-molt2 today pnpm install --offline pnpm exec tsc -p tsconfig.json --noEmit && pnpm test dsh web --patch ./cordis.mount.example.yml # the loom is in

STATUS: v0.2 — THE REBASE. SMOKE-GREEN [M] ON THIS MACHINE: TWO FOLDS, ONE SESSION, READ-BACK INTACT, FENCE PROVEN, RECEIPTS EMITTED, /MOLT LIVE THROUGH THE COMMAND REGISTRY. REMAINING BET-TO-MEASURED: THE LIVE WEB-PROFILE MOUNT AND A REAL MODEL RECALLING PAST ITS OWN FOLD. EVERY CLAIM ON THIS PAGE STAYS PINNED TO WHAT THE TAPE CAN BACK.

The session doesn't restart.

Your session already has a memory — it's the append-only log nobody folds, and a summarizer nobody can audit. MOLT is the missing seam: a fold at your pressure, a pointer to every byte, a fence that refuses what it can't prove, and receipts on everything — so the longest session on your machine stops being the one you keep restarting.

Compaction freed your context. MOLT makes it honest.
A fold for the DeepSeek Harness · sibling of TOWER and PROMPTER · the estate's laws apply: measured, or labeled a bet.