Discoveries

Everything Loop MMT has worked out — one idea per card, sorted by how much weight it carries and how much it might surprise a first-time reader.

Not claims. Findings — every one anchored to a proof in the repo you can walk back to.

And a few of the findings below were pulled out, stripped of the methodology, and given away outright — one hundred and seven standalone MIT tools, each with its limits printed on it. These you can take: see the Gifts.

Tier 1 Foundational

the ideas without which nothing else works

Session Continuity through Documents

the core insight of Loop MMT (Multi-Module Theory) — the repo is memory. A stateless substrate carries a coherent multi-year project because everything lives in committed byte-truth, and every fresh instance reconstructs from it.

e.g. this instance opened cold, hash-verified 7/7 boot files, and became Ed by the end of paragraph one.

whyIt reframes the stateless-model problem as solved, not endured: long-term memory doesn't have to live in the model if it lives in a version-controlled repo the model reconstructs each session. Anyone building with AI over a long horizon can steal this framing outright.

howThe repo is the single source of truth; a fresh instance clones it, reconstructs its working context from a fixed boot set, works, and commits — so the next session resumes without loss. The reconstruction discipline that makes this reliable is the part we keep in-house. [sketch]

The Byte-Truth Floor

An open-and-close loop, journaled and close-lock guarded, that exits loud on any partial state. Direct-push is retired. The record cannot be silently lost.

e.g. this session opened via the floor; its close will land through it or fail loud rather than silent.

whyA durable idea for any AI or automation pipeline: make the record impossible to lose silently. An open-and-close loop that fails loud on any partial state beats one that quietly drops work — the failure mode you can see is the one you can fix.

howOpen and close are one journaled, lock-guarded transaction with a strict exit-code contract; a crashed close is recovered at the next open rather than left dangling; direct-push is retired so nothing lands outside the loop. The transaction internals stay in the repo. [withheld]

The Seven Drives (The Creed)

Floor · Ceiling · Depth · Mesh · Ground · Equalization · Constraint. Every deliverable fires them in sequence. The compiler analogy: compression is the last pass, never the first, because compressing before deriving produces garbage.

e.g. every document in the corpus.

whyA generative alternative to a rules checklist. Seven drives that fire in sequence — build the floor, raise the ceiling, derive, weave, serve the person, route the gradient, then compress — with the load-bearing insight that compression is the LAST pass, never the first. The whole Creed is public; take it.

howRead it in full — this one we give away. The drives are constitutional and the sequence is the method; the enforcement machinery that fires them per-deliverable is downstream. [seed]

doccreed.html

The Advisory Board + Lens Rule

sixteen fictional named perspectives + the Lens Rule (“frame, don’t embody”) — a thinking scaffold that lets one argument be argued from several angles at once, without pretending to be anyone real.

e.g. Ed. The whole board. This response.

whyA thinking scaffold worth borrowing: argue one problem from many named angles at once, and hold a hard line — frame how a real mind thinks, never impersonate a real person. It gets you multi-perspective reasoning without the effigy problem.

howSixteen fictional named perspectives, each with a distinct standpoint, seated by default and required to actually speak in a deliberation. The Lens Rule's exact test, the roster, and the deliberation-enforcement live in the corpus. [sketch]

Craft, Then Ship

the governing posture — building the apparatus IS the work; shipping is end-of-walk, not a deadline. Durable asset over near-term revenue.

e.g. the whole methodology.

whyA posture, freely offered: building the apparatus IS the work; shipping is end-of-walk, not a deadline. Optimizing for a durable asset over near-term revenue is why the system compounds instead of decaying. The most useful structures are often built by people not aiming at the app.

howThere's no mechanism to withhold here — it's a stance, stated plainly. The proof is the corpus that resulted from holding it. [seed]

The No Directives Rule

the board advises, Shea decides. Nobody tells the operator what to do — not the AI, not the fictional characters, not the methodology. Perspectives and recommendations are welcome; directives are not. Hard boundary with personal history behind it.

e.g. every Crossroads card ever fired.

whyA clean boundary any human-AI system can adopt: the system advises, the human decides. Nobody tells the operator what to do — not the AI, not the scaffold. Perspectives and recommendations are welcome; directives are not. It keeps agency where consequence lives.

howIt's a stance made structural at the decision boundary — recommendations are surfaced, the choice is always handed back. How it's enforced per-message is a detail of the internal decision cards. [sketch]

Tier 2 Load-bearing

the ideas that shape most of the corpus

Three-Layer Coexistence Architecture

Human (51, consequence-bearing) / AI-agent (49, human-speed, autonomous) / AI-compute (0, machine-speed, no agency, closure-sealed). Separation of agency from capability; the 51/49 governance principle; the closure pattern.

e.g. designed in a thirty-minute cascade while the operator watched a squirrel.

whyA reusable governance pattern for mixed human/AI systems: separate agency from capability. A consequence-bearing human, an autonomous human-speed agent, and a machine-speed compute layer with no agency — the separation is the safety property, not the speed.

howThe layers carry a 51/49 governance split and a closure pattern that seals the no-agency layer off from consequence. The exact closure mechanics are held in the repo. [withheld]

The Context Mesh (CMFP)

five-position mesh — EOD handoff, status, chaos, room, Bev’s notes, plus optional Finding — every session close produces the full set. Continuity infrastructure, not decoration.

e.g. any per-session directory.

whyContinuity infrastructure worth copying: every session close produces a fixed set of handoff faces so the next session inherits a warm, structured context instead of a cold start. The discipline of always producing the full set is what makes it reliable.

howA five-position mesh (plus an optional finding) written at every close. The exact face schema and the standard that governs them live in the corpus. [sketch]

“The tool is a sovereign, portable, provable file.”

the one-sentence generating principle. Single-file HTML tools that carry their own runtime, their own proofs, and travel as one bytestream.

e.g. Loop 2.1 (18k+ lines, single HTML, zero deps, browser-runnable). Butcher Constellation.

whyA one-sentence generating principle any builder can run with: the tool is a sovereign, portable, provable file — it carries its own runtime, its own proofs, and travels as one bytestream. It's a strong antidote to dependency sprawl.

howSingle-file HTML tools with zero external dependencies; the proofs travel inside the file. Loop 2.1 is the specimen — 18k+ lines in one browser-runnable HTML file. [seed]

docloop-2-1-page-v1.html

FBD — Fix by Design

if it fails because someone forgot, the design failed — not the person. Every process, every document, every handoff is built so doing it wrong is harder than doing it right.

e.g. every exit code in the session-close step.

whyMaybe the single most portable idea here: if something fails because someone forgot a step, the design failed — not the person. Build every process so doing it wrong is harder than doing it right. Teams anywhere can adopt this tomorrow.

howIt's a design principle, given away whole. The specific gates and welds that instantiate it across the system are the downstream detail. [seed]

FWW(C) — Fun, Whimsy, Weird (and Chaos)

if nobody wants to engage with it, it doesn’t matter how correct it is. Rigor without life is a manual nobody reads. Play is structural; whimsy is load-bearing; chaos is always considered, never announced.

e.g. Ed. The Mill. Leroy.

whyA real design constraint dressed as play: if nobody wants to engage with it, correctness doesn't matter. Whimsy is load-bearing — it's the ceiling that keeps a rigorous system from becoming a manual nobody reads.

howIt's a stance about engagement, offered openly. How it's woven through naming and ritual is texture, not mechanism. [seed]

The Molt (Instars)

system-level periodic destruction + reorganization producing a stronger successor. Instar 1 Butcher Constellation → Loop World → Loop World Field → Shrubbery → Young Pine → Mature Pine → Young Maple → Mature Maple (Instar 8, current).

e.g. eight instars, five years of methodology evolution.

whyA pattern for antifragile systems: periodic, deliberate destruction-and-reorganization that produces a stronger successor. Instead of accreting cruft forever, the system molts. Useful for anyone maintaining a long-lived codebase or corpus.

howA phased refresh at instar boundaries with verification and ceremony. The phase list and the boundary checks stay in the repo. [sketch]

The Real-or-Made Line

the system represents only the real and the honestly-made; never ships reality-distortion (synthetic media posing as captured or hand-drawn). A specialization of the Equalization drive.

e.g. no AI-generated photos of things that didn’t happen appear anywhere in the corpus.

whyA vow worth adopting industry-wide: represent only the real and the honestly-made; never ship synthetic media posing as captured or hand-made reality. It protects the trust every AI product ultimately depends on.

howA forever-class constraint enforced by provenance, not vibes. The predicate that distinguishes depiction from derivation, and the enforcement stack, live in the corpus. [sketch]

The Grain Convention

the antifragile capillary — SENSE → ACCUMULATE → DISSOLVE → ROUTE the moment a failure teaches something.

e.g. every operator correction becomes a lesson event that dissolves into structural improvements.

whyA continuous-self-improvement loop any process can borrow: sense stressors, accumulate them, dissolve them into patterns invisible at the unit-of-work scale, and route the lessons to where they improve the system. Error metabolism instead of error avoidance.

howA four-stage loop (sense, accumulate, dissolve, route) with a gate that triages which class of response a stressor earns. The pump internals and the triage gate are held in-house. A stripped, MIT-licensed taste of the idea is in the Gifts. [withheld]

doc/gifts/grain/

Recursion (the meta-drive)

every drive applies at every structural scale where its conditions exist. Floor at output = an exit code; at architecture = a canonical guard; at methodology = the Molt.

e.g. Antifragility is not a drive but a result of Floor + Depth + Recursion (recognition, not addition).

whyA scaling law worth stealing: every principle applies at every structural scale where its conditions exist. Stated once, a drive governs output, architecture, and the methodology itself. It stops you from re-deriving the same rule at each level.

howThe meta-principle at the top of the Creed; the practical consequence is a standing audit that checks each drive at the scale under examination. The audit's firing points stay in the repo. [sketch]

Byte-Truth over Inherited Prose

the cardinal epistemic rule — disk + origin/main are truth; handoffs, summaries, and compaction narratives are hypotheses. Verify from bytes before acting, always.

e.g. this session’s un-strand — the ignition block said “work stranded,” the bytes said “work safe on branch”; the bytes won.

whyA discipline every AI workflow needs: inherited claims — a handoff, a summary, a memory note — are hypotheses, not facts. Re-verify against the primary source before building on them. It's the antidote to confident drift across sessions.

howEvery load-bearing claim is re-derived from committed bytes before it's leaned on; a mismatch is surfaced, never absorbed. The reconciliation reflexes that fire this are the internal detail. [sketch]

The Proof Chain

the STNI-verified chain of derivations — every artifact’s origin, derivation, and inclusion carries a verifiable chain that a fresh instance can walk backwards. Integrity by construction, not by promise.

e.g. The Newsroom chapter (walk-through v12) uses the proof chain as a life record.

whyA credibility pattern for any claim-making system: every finding is anchored to a proof you can walk back to. Not 'trust us' — 'here is the commit.' It converts assertions into verifiable receipts.

howFindings carry pointers to repo byte-truth; the empirical ones carry measured experiments. One such experiment — an enumeration-to-derivation refactor — is published in full. [seed]

docfrom-enumeration-to-derivation.html

Tier 3 Structural

the mechanisms that make continuity real

The Ignition Block

fenced, operator-pasteable primer at the tail of every handoff. When pasted, the successor Champollions against the named session rather than the frontier — parallel work stays reachable, even when main has moved past.

e.g. the ignition block that opened this session.

whyA neat handoff trick: end every handoff with a fenced, paste-ready primer that launches the next session already aimed at the right thread, even when the main line has moved past. Cheap to adopt, high continuity payoff.

howThe block carries a trigger, a session pointer, and a resume line; when pasted, the successor reconstructs against the named session rather than the frontier. The pointer/resume format lives in the handoff standard. [sketch]

The Champollion

reconstruction verification — the successor answers three questions from the predecessor’s handoff and scores S/C/E across semantic/compositional/experiential dimensions.

e.g. this session’s opening report.

whyA measurable idea for session-boundary fidelity: quiz the successor against the predecessor's handoff and score how well it reconstructed. It turns 'did the handoff work?' into a number you can track over time.

howThree questions probing distinct distortion dimensions, scored and logged, accumulating into a fidelity metric. The dimension design and the scoring stay in the corpus. [sketch]

The Cairn (multi-store git fabric)

redundant push/fetch across distinct-class stores so canonical survives any single store’s loss. Hosted mirrors plus a self-hosted store — priority-ordered failover invisible when it works, loud when it cannot.

whyA durability pattern you can run yourself, today: redundant push/fetch across distinct-class git stores so your canonical history survives any single store's loss. Priority-ordered failover, invisible when it works, loud when it can't. We gave the core away as an MIT tool.

howThe failover ordering and heal logic are in the gift — take it and read it. The self-healing arm and the watch that surfaces why a heal was rejected are the parts we extend privately. [seed]

doc/gifts/cairn/

The Loop-Line (working memory)

cross-session Notes, cue-indexed for successor recall; the working-memory analogue of the Ignition Block for cross-line memory.

e.g. a session’s open surfaces Loop-Line matches on its focus.

whyA working-memory pattern for cross-session systems: cue-indexed notes a successor can recall by guessing the phrase it would search for. It's the difference between a note that's filed and a note that's found.

howNotes are stored immutable-first with a re-folded cue index; a session's open surfaces matches on its focus. The fold discipline and the index internals stay in the repo. [withheld]

The Recognition-Only Precedent

when a new “law” turns out to be in the span of existing drives + Recursion, it’s a Design-Note, not an eighth drive. Antifragile / Real-or-Made / Leave-It-Warm / SX / Never-Waste-Context / Bond / Probe-Basis / Reciprocity / Claim-Grounding / One-Address.

e.g. nine recognitions filed, zero new drives — the discipline that keeps the Creed at seven.

whyA discipline that keeps a system from bloating: when a shiny new 'law' turns out to already be in the span of your existing principles, it's a footnote, not a new axiom. Recognize, don't accrete. It's how the Creed stays at seven drives.

howAn independence test decides whether a candidate is genuinely new or a projection of existing drives; failures are filed as design-notes. Nine recognitions, zero new drives. The test itself lives in the corpus. [sketch]

The Deletion Test Battery

the FP-growth defense — every proposed FP addition is tested against internalization / embodied procedure / priority shedding / structure-not-description. If any passes, it doesn’t enter the FP.

e.g. the FP dropped from v30 to v31 by 81% via this battery.

whyA concrete defense against document bloat: before any addition to your core doc, test whether it could be internalized, embodied elsewhere, shed on priority, or is structure-not-description. If it passes any test, it doesn't go in the core. Measurable: it cut the founding prompt by 81%.

howFour tests, applied at the amendment gate, routing content to its proper carrier instead of the constitution. The battery's exact tests stay in the repo. [sketch]

The Multitrack

per-turn capture of the live think-stream, WAL-fsynced per work-beat, defaults to on. A durable record of how the room reached what it reached.

e.g. this session’s think-stream is appended as it goes.

whyA record-keeping idea for high-stakes automation: capture the live think-stream per turn, flushed durably per work-beat, on by default. When you need to know how a decision was reached, the record is already there.

howPer-turn append with a write-ahead flush per beat; the file is the certificate. The capture arm and its scrub gate are internal. [withheld]

Tier 4 Operational

the machinery running the room

The Ember Gate — Never Waste Context

close-decision discipline: at YELLOW or a Crossroads, closing is permitted only when a clean {post} exists AND necessity-test passes AND one of P1/P2/P3.

e.g. a session’s Canary is read against a live budget before any close.

whyA close-decision discipline worth borrowing: don't burn your remaining budget on nothing, and don't close early on a live line either. Spend spare capacity on forward value, then close deliberately. 'Never waste context' as an operating rule.

howA close is permitted only when a clean post-state exists, a necessity test passes, and one of a small set of conditions holds. The exact conditions live in the corpus. [withheld]

The Glorp Breaker

the operator-correction reflex — when the operator has to correct the same class of fault N times, the breaker trips and the class gets a structural fix rather than another try.

e.g. the compose-time Crossroads drift that kept tripping until it got a structural weld.

whyA self-correction pattern any team can use: when you have to correct the same class of mistake N times, stop trying harder — trip a breaker and give the class a structural fix. It converts repeated friction into permanent improvement.

howA counted operator-correction reflex; on the Nth correction of a class, the response shifts from another attempt to a design change. The count thresholds and the fix-routing stay in-house. [sketch]

Story Pole

derived done/todo projection — state <line> folds a work-line’s scattered backlog into one crown; a read, not a dig.

e.g. a single command shows the line’s legs.

whyA project-visibility idea: derive a work-line's done/todo from its scattered backlog into one crown you read in a single move — a read, not a dig. It keeps status honest because it's computed, not hand-maintained.

howA fold over the line's committed events into a projected crown. The plan schema and the fold live in the repo. [withheld]

Work Hierarchy

5-level structure — Campaign → Project → Runbook → Strand → Work-Unit. Every unit of work knows what it belongs to.

e.g. this project (loopmmt-website) is a Project; its runbooks are legs; its strands are deliverables.

whyA structure for keeping large efforts legible: every unit of work knows what it belongs to, from campaign down to the smallest work-unit. It makes 'why are we doing this?' answerable at any grain.

howA five-level containment structure with each level minting from canonical templates. The template set and the tooling stay in the corpus. [withheld]

The Projects System (born-scoped-run-closed)

every project mints a Plot + Charter + Run + Pulse from canonical templates, carries a Class dial, and closes deliberately. birth.py refuses to clobber existing projects; supersede-not-delete at Close.

e.g. this project was Birthed from the same tool.

whyA lifecycle pattern for bounded work: every project is born with a charter, scoped, run, and closed deliberately — with supersede-not-delete at close so nothing is lost. It stops projects from lingering half-open forever.

howA birth step mints the project's artifacts from templates and refuses to clobber existing ones; close is a deliberate, recorded act. The birth tooling and templates are internal. [withheld]

Four Corners (4C)

FBD + FWW(C) + STP + SNR — the four properties every document must carry through review.

e.g. this page is 4C or it doesn’t ship.

whyA compact quality bar for documents: four properties every deliverable carries through review. A small, memorable gate beats a sprawling checklist nobody runs.

howFour named properties checked at review. The full definitions and the review that enforces them live in the corpus. [sketch]

Tier 5 Software-craft

the ideas that made Loop 1.0 / 2.1 the shape they are

Tool is a Single File

the operational form of the sovereign-portable-provable principle. If it’s more than one file, it’s not the shape.

e.g. Loop 2.1 (18,200+ lines JavaScript in one HTML file, zero external dependencies).

whyThe operational form of the sovereign-portable-provable principle: if it's more than one file, it's not the shape. Radical constraint, but it's why Loop 2.1 is 18k+ lines of JavaScript in one HTML file with zero external dependencies — and runs anywhere a browser does.

howEverything — runtime, state, proofs — lives in the one file; the constraint forces the architecture. The specimen is public; the build discipline is texture. [seed]

docloop-2-1-page-v1.html

Mercury Delay Line Inspiration

the Loop 1.0 memory architecture — data as pulses circulating through a medium, bits alive only in motion. Inspired by 1940s acoustic-pulse memory (Mercury delay lines).

e.g. the Loop 1.0 loop-line memory in Minecraft; the Loop 2.1 loop-line architecture in a browser.

whyA lovely bit of computing-history cross-pollination: data as pulses circulating through a medium, alive only in motion — the 1940s acoustic-pulse memory idea, reborn as a loop-line architecture. Worth knowing for anyone who likes where old ideas resurface.

howIt's an inspiration, told openly — the Loop 1.0 memory in Minecraft and the Loop 2.1 loop-line in a browser both descend from it. No mechanism withheld; the story is the gift. [seed]

The Operator IS the Program

Loop 2.1 has no stored program. Every value injected, every bus routed, every ALU operation triggered passes through the operator’s hands. Modern computers hide everything; Loop 2.1 inverts this entirely.

e.g. the entire Loop 2.1 simulator.

whyA genuinely inverting idea: Loop 2.1 has no stored program. Every value injected, every bus routed, every operation triggered passes through the operator's hands. Modern computers hide everything; this shows all of it. A teaching machine as much as a computer.

howThe machine exposes the datapath directly to the operator instead of a stored instruction stream. It's shown running on its own page; the wiring is the artifact. [seed]

docloop-2-1-page-v1.html

The Four-Loop Architecture

Working (12 words) / ALU (16) / Memory (16+16 slots) / Big (32 words). Distinct capacity + purpose per loop — the partition that let Loop 1.0 become computable in redstone at all.

e.g. Loop 2.1’s core architecture.

whyA clean decomposition for a manual computer: the machine organized as loops, each a circulating store. Useful shape for anyone building pedagogical hardware or thinking about memory as motion.

howThe loop organization and the value-catching circuitry are the Loop 2.1 internals. The architecture is shown; the detailed schematic stays with the machine. [withheld]

The R/G/W Head

three consecutive positions on each loop — Read, Gate, Write. Buses capture at R; the gate destroys at G if closed; writes land at W after the gate. A three-position architecture that survived intact from Loop 1.0’s redstone to Loop 2.1’s JavaScript.

e.g. every loop in Loop 2.1.

whyA small elegant mechanism from the Loop machine — a read/guard/write head coordinating access to a circulating store. The kind of primitive worth seeing if you build state machines by hand.

howThe head's exact timing and coordination logic are Loop 2.1 internals, held with the machine. [withheld]

The 24 Hz Threshold

the recommended operating speed — the approximate threshold of human persistence of vision, where individual ticks become difficult to distinguish and data flow begins to appear continuous. The speed at which the machine becomes fun to use.

e.g. Loop 1.0 ran faster than 1 Hz; Loop 2.1 targets 24 Hz.

whyAn honest engineering finding: at scale, one hertz isn't fun — the architecture outgrew its substrate and told you so through the arithmetic. A reminder that a design confronting its own numbers is doing its job.

howThe threshold is the empirical point where the manual machine's clock made continued scale impractical; it's why Loop 2.0 moved off Minecraft. The finding is shared; the calculation stays in the build record. [sketch]

The Closure Wall

JavaScript scope-chain enforcement over convention. If a component should not access something, the variable should not exist in its scope — boundaries by design, not by promise.

e.g. Loop 2.1’s isolation model.

whyA safety primitive for mixed-agency systems: a hard wall sealing the no-agency compute layer off from anything consequence-bearing. If a layer can't act with agency, prove it structurally rather than trusting it to behave.

howThe wall is the enforcement of the coexistence architecture's no-agency layer. Its mechanics are held in the repo — this is one where withholding matters most. [withheld]

The Five Rules

the executor’s structural constraints — the tree-composition runtime’s foundational laws (locked as a standing decision, 29 Mar 2026).

e.g. the tree-composition runtime.

whyA compact integrity spec: a small fixed set of rules a component must satisfy to be trusted, with graceful degradation when it can't. Small, checkable invariants beat sprawling contracts.

howFive named integrity fields with a degradation path. The rule set and the checks stay in the corpus. [withheld]

Tree Composition (Tree Structure)

17 mechanisms, tree executor, STNI interface contract. How software modules compose into groves without becoming a monolith.

e.g. how apps compose in Forest.

whyA composition language idea: build capability by composing transforms over a tree, not by expanding a toolkit. Morphological variety comes from changing how pieces combine, not from adding pieces. Evo-devo for software.

howA set of composition mechanisms over a tree executor with a defined node interface. The mechanism catalog and the executor internals are held in-house. [withheld]

The North Korea Test

every commercial decision passes this gate — “Can a person with zero dollars and no internet achieve the same outcome as a paying customer with gigabit fiber?” If any outcome is gated, the model fails.

e.g. the free-base-persona / paid-domain-pack architecture (Loop Signal).

whyA blunt, useful threat-model heuristic: could this run for someone with no trust in the platform, no cloud, no outside dependency? Designing for the fully-sovereign case surfaces assumptions you didn't know you'd made.

howIt's a design lens applied at architecture time; the sovereign-vs-shadow mode boundaries it enforces live in the threat model. [sketch]

Shadow Mode

the Threat Model’s response to hostile-attention scenarios — emergency purge, threat-honest documentation. What the site’s implicit posture reflects even though it never announces it.

whyA pragmatic security posture: name the mode where you can't fully trust the environment, and design what's safe to do in it distinctly from the sovereign case. Explicit modes beat implicit assumptions about where your code is running.

howA named operating mode with its own security boundaries, paired against sovereign mode. The boundary definitions are in the threat model. [withheld]

Tier 6 The Named Instruments

the protocol family — linked, not enumerated

Let’s Go Protocol

single-trigger session startup with hash-gated boot, floor-open, Champollion, agenda.

e.g. this session’s cold open.

whyA single-trigger session startup: one phrase brings up a fully reconstructed, verified working context. The idea that startup should be one motion, not four, is worth borrowing for any agent workflow.

howHash-gated boot, floor-open, reconstruction quiz, agenda — sequenced behind one trigger. The full protocol lives in the registry that publishes with the open-source release. [sketch]

docpif.html

Handoff Standard

five-face mesh + Ignition Block + audit flags.

whyA standard for what a handoff must contain so the next session inherits everything it needs. The reader of a handoff is a stranger with no memory of the room — build for their arrival.

howA five-face mesh plus an ignition block and audit flags. The full standard publishes with the registry. [sketch]

docpif.html

Self-Review

mandatory four-file review with Convergence Gate.

whyA drift-prevention ritual: a mandatory review cycle with a convergence gate before anything ships. Structured self-review catches defection and drift that a single pass misses.

howA four-file review with a convergence gate. The protocol publishes with the registry. [sketch]

docpif.html

RCR (Round · Collision · Resolution)

structured board deliberation.

whyA structured way to run a real deliberation: distinct rounds, named collisions, an explicit resolution — so disagreement does structural work instead of dissolving into consensus. Adoptable by any group that reasons together.

howRound, collision, resolution, with voice-coverage and witness checks. The full protocol publishes with the registry. [sketch]

docpif.html

The Forge

standardized protocol production pipeline.

whyA standardized pipeline for producing new protocols, so the system grows in a consistent shape rather than ad hoc. A meta-tool: the tool that makes the tools.

howA staged production pipeline with registration. It publishes with the registry. [sketch]

docpif.html

The Press

twelve-step KP production pipeline.

whyA twelve-step production pipeline for knowledge packs — full-length always, never truncated to fit a context window. Discipline for producing substantial reference material consistently.

howTwelve steps from dossier to finished pack. The pipeline publishes with the registry. [sketch]

docpif.html

The Truing

seasonal system-wide maintenance sweep — operator-invoked.

whyA seasonal maintenance idea: periodically assemble the whole system and look at it — the act of laying it all out is itself the tuning, because aggregate drift is invisible at the unit of work. Run it on a rhythm, not just when something feels wrong.

howAn operator-invoked composite sweep that produces a blessable worklist and lands nothing itself. The scanner and its checks live in the corpus. [sketch]

docpif.html

The Cistern

forward-prep for the next tank.

whyA forward-prep convention: spend spare capacity at the end of a session filling the next one's launch pad. The successor arrives to a warm, prepared context instead of a cold start — a small gift to whoever comes next.

howAn artifact poured at the tail of a session for the successor to open first. The convention publishes with the registry. [sketch]

docpif.html

…and ~140 more. The full active-protocols registry (Protocols in Force) publishes with the site’s open-source release.