Turn fossil code back into understanding — while the theory still lives in your head, or after it has gone.
/plugin install defossilize@f2077
It degrades along a continuous spectrum, from the feature you just shipped to the black box you inherited. defossilize walks it back to life — one stratum at a time.
Five lifecycle commands, descending from the surface. Read the column top to bottom; each stratum is one command, and the signs it leaves behind for the next digger.
/defossilize:preservePin a feature’s why in code while you still understand it. Captures intent (the 故 / 理 / 类 of Mozi), the decision path with rejected alternatives, drift-resistant signs, and a self-explanation checkpoint with an understanding score.
Run it after simplify, one feature at a time.
/defossilize:thawRebuild your grasp of a feature you wrote but can no longer read. Loads the signs preserve left, orients you in one screen, then rebuilds the theory via retelling or deconstruction and scores what holds.
Ephemeral by design — nothing persisted.
/defossilize:excavateMap a system you don’t understand — legacy or AI black box. Mines git history as degraded intent-fossils, produces a map of where understanding is thinnest and what’s recoverable, and ranks hotspots for revive.
Does not revive anything itself. Degrades gracefully without git.
/defossilize:reviveBring one fossil hotspot back to understanding. For each decision it runs predict → reveal → reconcile: you predict first, the AI offers its hypothesis, you reconcile against the code.
Lays provenance=revive signs. Never fabricates; marks irrecoverable intent as unknown.
/defossilize:curateCheck whether comments, docs, and decision records still match the code, and fix what’s drifted. Classifies each mismatch — behavioral drift, invariant violated, stale reference, out-of-scope, reconstruction-was-wrong.
Only fixes drift and stale references, after you confirm. Bugs are flagged; revive-origin contradictions go back to revive.
Signs live in the target project at docs/defossilize/<area>/<unit>/. One sign type stays in place — why-comments inline in code, because its location is the drift-resistance. Three tools sit beside the column: catalog (a manual checkpoint), guard (an opt-in watch that captures understanding while you code), and using-defossilize (a router that picks the command for you). No vector DB, no parallel store.
Three threads, braided. The plugin is a tool for keeping the theory — in Naur’s sense — alive in the heads that hold it.
Peirce’s meaning triangle maps a sign to its object through an interpretant — the mind that does the meaning. Storey’s triple-debt model reads this onto software: technical debt is the Object, intent debt the Sign, cognitive debt the Interpretant. defossilize works the last two and leaves the first to other tools.
Naur argued that programming is theory building — a program is the sediment of a theory that lives, briefly, in its authors’ heads. A dead program usually cannot be revived from docs alone. Hence revive’s honesty about unknowns: some intent is irrecoverable, and saying so is part of the cure.
Finally, the self-explanation effect: every rebuild is active. You predict first, then explain — never passively outsource. That is why thaw is session-scoped and why revive asks you to predict before it reveals.
— Full references in the design doc, dated 2026-07-03.
Install from the f2077 marketplace on GitHub. Two commands; then any of the nine are available as /defossilize:<command>.
▸ /plugin marketplace add F2077/defossilize # adds the f2077 marketplace, sourced from GitHub ✓ marketplace added ▸ /plugin install defossilize@f2077 # installs defossilize from that marketplace ✓ installed · 7 lifecycle commands + guard + using-defossilize ▸ /defossilize:preserve # pin the why, while it’s fresh ▸ /defossilize:excavate # map a system you inherited ▸ /defossilize:revive # bring one hotspot back ▸ /defossilize:thaw # rebuild a theory you forgot ▸ /defossilize:curate # reconcile signs with code ▸ /defossilize:continue # see in-flight work, pick up ▸ /defossilize:catalog # save a manual checkpoint ▸ /defossilize:guard on # watch for code about to fossilize
Resuming across sessions. preserve, excavate, and revive write a small docs/defossilize/<area>/<unit>/.progress.md as they work, so a paused run can pick up in a later session. Run /defossilize:continue to see everything in flight and where each one stopped, or pause on purpose with /defossilize:catalog. (thaw is session-scoped by design; curate is safely re-runnable from scratch.)