Protocols — a funnel, not a dump

Tier A — the whole registry

The methodology runs on about 166 protocols in force. Everything below is a subset of that registry — a taste of a much larger set.

Tier B — some of the names

A sample of protocol names, each with a one-line sense of it. Just the names here — how each one works is held back at this tier.

• The Chronicle — A git-log/work-log report over a span of sessions
• The Trellis — A 2-D consistency localizer + generator
• The Teardown Kit — The Red Team's verification ISA
• CX — The Context Exchange — The whole-ladder context gauge
• The Waterline — CX organ 3
• The Multitrack — The capture-at-open session-transcript system
• The Loop Deck — The integrity-gated generative draw plus bounded self-mod
• The Color — The primitive under The Palette: XYZ hub, ok1 address, ΔE00 tolerance, recipes
• The Typeset — Type roles bound to typefaces, per surface
• The WO Kit — First stop for building any Work Order
• Handoff Standard — EOD handoff structure with mesh sequencing, audit flags, session filing amendment
• Day Sheet Protocol — CMFP-derived inline mesh for multi-session days
• Context Mesh Factoring Protocol — Five-position decomposition for observer documents (six with The Finding)
• The Forge — Standardized protocol production pipeline
• The Chain — A derived multi-line session-chain registry: folds the `[CHAIN]` header over committed EOD handoffs into the `chain` and `lines` reads
• The Concord — N-party verified consensus
• You Tell Me — Board-driven priority selection when operator defers direction
• Process Pulse — Inline process measurement
• The Verification System — Cheap re-check of a learned fact against a kept certificate
• Crow's Nest — Whole-system assessment
• Sitrep — Mid-session state snapshots for cross-tab coordination
• The Kiln — KP Revision Protocol
• The Sweep — Systematic filing verification. v1.3: Reverse Pass amendment
• The Last Call — Autonomous session lifecycle management
• Super Write — Multi-column writing protocol. Derive-architecture form. Full DDE composition
• The Sensorium — Multimodal prompt composition
• The Dock — File-level workflow control for multi-file deliverables
• The Foundry — Specification-to-software pipeline
• The Stitch — Protocol integration assessment
• The Cellar — KP corpus maintenance protocol. Four phases. Wine-cellar aging
• Panner Gold Dust Protocol — Campaign-to-protocol generalization. Two-phase pipeline (Divergent/Convergent)
• The Tune — Cohort alignment protocol. v2-A1: Consonance amendment
• The Errand — Bounded delegation protocol
• The Survey — Cascade bridge protocol
• The Cascade — Protocol composition. v1.1-A1: Block Principle convergence
• The Slice — Image examination at resolutions above native downsampling
• Resurface — Structured resurfacing of buried work items
• The Resonance — Audio-to-waveform detection and registration pipeline
• The Trophy Case — Achievement documentation
• The Christening — Naming ceremony protocol. Demo stack
• The Proof — Post-build scaffold calibration. Light/Heavy tiers. Q0 Mechanical Pre-Scan. Q4 materialization mandate
• The Meme Protocol — Cambium domain protocol
• The Confidence Board — Secondary advisory panel specification. Spore branch origin
• The Mast Step — Building design protocol. Spore branch origin
• The Liner Notes Protocol — Enriched music context for the Sensorium's audio channel. Record format (five channels), Stacks (three tiers), four trigger paths. Composes with Sensorium, Preset Library, Waveform Generator, and Shuttle `\| \|` audio fence. Origin: S~163
• The Gauntlet — Chaos-injection harness: one typed fault (DRIFT/STALE/CORRUPTION) at one typed target on a disposable sandbox clone, measured against a declared steady state; HELD/BREAK to the Back Room
• The Core Sample — Grain extraction pipeline
• The Customs House — The R4 external-context security gate

Tier C — a few, in full

A small, chosen set of protocols shown in their entirety — the real text, plumbing details aside.

The Sounding

# The Sounding — Operator Re-Orientation Readout · v1.2

> v1.1 (S02.1410-noble-beacon-1stxvw, operator directive: "more detailed numeric updates folded into what a Sounding Report should be"). A seventh slot, THE COUNT, rendered from the line's Dial and its delta — never said. Specimen that motivated it: the same session gave a hand-said "16 new configurations" that the bytes said was 24.

## What this is A bounded, operator-invoked position report on one Work Line, assembled from byte-truth registries, for the moment the operator is in the weeds on a Thing and needs a quick re-orientation on where it stands. You ask where you are on a line; the instance reads the line's real record and hands back a compact readout.

It is the inverse of the Conn-pass. The Conn-pass is the board handing the conn back at a boundary, carrying a state line. The Sounding is the operator pulling that same kind of state mid-line — and the conn never moves. You stay steering; it raises your situational awareness, not anyone's authority.

## Where it sits (the readout family) Three state instruments at three scales; this one fills the on-demand, single-line middle:

| Instrument | Scope | Direction | When | |---|---|---|---| | The Handrail | this message | system → operator | every message (micro-state) | | The Sounding | one Work Line | operator → request → readback | on demand, mid-stream | | The agenda | the whole frontier | system → operator | automatic, at session open |

(Distinct also from session-state — global, rendered at close — and the Logbook — retrospective corpus reconstruction.)

## Trigger An operator speech act, conn-holder only: "where are we on X?" · "take a sounding on the <line>" · "I'm lost on Y" · "re-orient me on Z." Recognition-triggered, like the Stake.

Scoped to exactly one line. If the named target spans multiple lines or is ambiguous, the instance either names the candidate lines and asks one clarifying question, or fixes the single most-likely line and says which. It never reads the whole frontier — that is the agenda's job.

## The readout — seven fixed slots Assembled, never authored.

1. THE LINE — what thread this is, one sentence: the line id/name + what it is about. (Scope anchor.)
2. THE SHAPE — the gestalt in one breath, so the operator re-grips the Thing whole. (The re-orientation core.)
3. SETTLED — what is locked, each item marked board-convergent vs operator-decided. (Honesty split — mandatory.)
4. OPEN — what is pending / being worked, each item marked whose call it is. Reports a dead or parked line as dead or parked.
5. NEXT — the immediate next move / where the line is poised. One item, forward-pointing.
6. WATCH — live hazard / Scope-Fence note, if any. Omitted if none.
7. THE COUNT (v1.1; v1.2) — the line's numbers, rendered, never said. Mandatory rows on every line (C21): crown slots done · crown slots left · tracked to-do (slots + owed) · owed open · line Notes open · sessions on the line — from story_pole.py state <line> and session_count.py <line> (or sounding.py render <line> once it lands), whether or not the line has a Dial. Then the line's own Dial:

- where the line stands: — each declared stat, folded from its oracle; - what the current work changed: — the same stats folded over origin/main and over the working tree, and the signed difference. Shown as one small table — stat · main · now · this session — with done / total / left where the Dial declares them, then one line naming what the numbers do not count (work no stat covers yet, e.g. a slice with no board).

…then one mandatory footer:

- SOURCES — the registries this Sounding was read from (the line fold · the line's RCR/findings/handoff · session-state · the DAG), and for THE COUNT the two Dial commands and the base ref's short hash. One line. (See Control 1.)

### The COUNT's rules (v1.1) - Every number in a Sounding is a Dial value, or it is cut. No hand count, no recall, no arithmetic done in prose — the same Ground-Truth rule as Control 1, applied where fabrication is easiest to miss. - No oracle, no number (v1.2; retires v1.1's no Dial, no numbers). A line with no Dial still gets the mandatory rows above, because every line has them. A stat no oracle computes is shown n/a (<reason>), never hand-filled. A Note to declare a line Dial is filed only for line-specific stats. - Every label names its construct (v1.2): Crown slots left and Tracked to-do (slots + owed) are different numbers on the same line (self-description-at-birth: 2 and 4) and are never both called "left". - Declared is not proven. A stat that counts what is declared (a board's claim lines) and not what is run (the board's witnesses) says so in its row; the run belongs to its own instrument. - Read a new stat once against what it says it counts before trusting it. (S02.1410: the first draft of this line's "State models" stat counted the test files too — 16 for 8 — and the first read caught it.) - Units are the stat's. A count of slots is not a count of effort; the "does not count" line says what the table leaves out.

### The cap (testable) A Sounding is a fix, not a findings report. The cap is on prose, not on numbers (v1.2): each prose slot ≤ 2 lines; THE COUNT is one table — stat · main · now · this session — of at most a dozen headline rows, the rest named behind one command. Why the cap moved: v1.1's "fits one view" was protecting the operator from findings-report sprawl and got applied to numbers by mistake; numbers in a fixed table are cheap to read, paragraphs are not. Findings that won't compress go to their own report with a pointer, never into the Sounding. It must never become the weeds it exists to escape.

## The two load-bearing controls

1. Ground-Truth binding, made auditable (Cash-Out Rule). Every claim traces to a real registry read — the line fold, the line's RCR/findings/handoff, session-state, the DAG, the Crossroads picks — read from the clone, not the mount; uncitable → cut, never invented. The binding is made visible by the SOURCES footer: a Sounding with no SOURCES line, or one citing nothing real, is a visible defect, not an honor-system lapse. This matters because fabrication is silent (Orientation KP: an under-modeled agent cannot itself tell "I know this" from "I am generating plausible text") — so the control must leave a checkable mark. A Sounding from memory is forbidden: a confident wrong fix re-orients the operator onto a wreck, worse than leaving him knowingly lost. (Inherited from the Kaleidoscope's Ground-Truth Rule.)
2. Settled-by-whom honesty. Board-convergence and operator-decision are never blurred. A recommendation is never presented as a decision. A dead line is reported dead.

## Wiring (relationship to the Conn family) - Conn command (registers in the Conn Convention beside the Stake): a speech act inside whatever mode is live, transferring no conn. The operator holds the conn before and after. - Adjoint to the Conn-pass: same state object, opposite direction, conn invariant. A Sounding commonly precedes a Conn-pass or a Crossroads — fix position → decide → advance. - Work Line is the unit. The Muster says who is in the room; the Conn says who steers; the Sounding says where the line is.

## What it is NOT (ontology, stated once) Not a build, not a decision, not a handoff. It changes no state; it reports it. The conn stays with the operator throughout. It does not fire a ledger did: event — a Sounding is a read, not a Thing We Did.

## Status — SEALED (Seat complete, S06.0814) ACTIVE, SHIP-document (review + fire-drill cleared S06.0601). Name CALLED (the Sounding, S06.0601). Seat complete S06.0814 (operator A): Conn Convention conn-command wire (v1.1→v1.2, the Stake's pattern) · PiF Active row + Conn row bump + patch entry · Glossary v36 entry · Handrail + Let's Go agenda reciprocal readout-family cross-ref · Field Manual Sounding Standing Instruction — all landed. Named follow-on (not a blocker): sounding.py, the line fold helper, armed once the Event Codec line field lands.

Loop MMT™ · The Sounding v1 · S06.0601 · "When you can't see the bottom, take a sounding. Off the chart, never off your memory." © 2026 Shea Gunther · New Gloucester, Maine · CC BY-NC 4.0

The Altimeter

# The Altimeter — the read of a goal's altitude When a decision pulls against itself, zoom the intent out until the move is coherent, and let the higher altitude govern.

What this is. A read-only discipline for reading the altitude of intent in a live decision. Its output is a reading and a governing choice — never a stored structure, never a tool. It is the Sounding's sibling: where the Sounding reports the state of one Work Line on demand, the Altimeter reports the altitude stack of one decision at the moment that decision pulls against itself. It is loaded when needed (a Field Manual standing instruction carries the trigger), not at every open.

## The recognition (the load-bearing finding) Goals have altitude. Intent runs on a continuous zoom from the immediate Act (the move in your hand) up to the Telos (the whole game / the constitution). This is the Creed's Recursion law pointed at a new axis — not structural scale (output / architecture / methodology, where Recursion already governs the drives), but intent-altitude (time-horizon × stakes-scope). The axis is anchored at both ends by things that already exist: - The apex is the constitution. The top of the goal stack is the Threshold — operator + Jamie + the constitution — the same apex the Tally's names_threshold guard already enforces. The highest goal is not invented here; it is read off what is already written. - The floor is the act. The bottom is the immediate move, the thing in front of you right now.

The Altimeter only ever reads between the pinned apex and the act-floor. (The atlas rule holds: the edge from Recursion to intent-altitude is claimed by derivation — a named new coordinate of one existing law — not by resemblance to the Maps-zoom or the 4Quad. "It all maps to everything" is the numerology the Field Model peeled; this is not that.)

## The detents — continuous, read at three A map has no native number of zoom levels; it is continuous, and you read it at a few useful detents. (House precedent: the Chronoscope reads the continuous deep-time axis at four evidence-placed detents.) The intent axis is read at three working detents, apex fixed:

| Detent | The frisbee read | The goal at this altitude | |---|---|---| | Act (floor) | this throw, stall-8, two seconds | "don't turn it over right here" | | Campaign (middle) | this point / this possession | "score, or at least deny them a free score" | | Telos (apex, fixed) | win the game (= the constitution) | "maximize win-probability over the whole" |

Why three, not two or five. Two is too few to hold the punt — you need the Campaign middle to see that surrendering this point still serves the game. Four–five is too many because the band is bounded: nothing lives above the Telos (the constitution is the ceiling) and nothing below the Act (the move in your hand is the floor). The usable band is small; three detents span it. (The operator's own instinct — "two or three; four-five too many" — was correct; this records why.)

## The read (the four-step move, fired at the punt moment) The Altimeter fires when a decision pulls against itself — a low move would violate a low goal but might serve a high one:

1. Name the goal at each detent — Act, Campaign, Telos.
2. Zoom out to the altitude at which the move is coherent.
3. Let the highest applicable altitude govern. (The punt: throwing the disc away is a turnover at the Act, correct at the Telos. You give up the Act-goal and half the Campaign-goal to serve the Telos-goal — and the Telos governs.)
4. If the higher altitude governs at the cost of a lower goal, that is a Tally moment — hand to the Tally: cut one notch, recorder ≠ beneficiary, log the cost. The Altimeter decided which altitude wins; the Tally pays for and records the sacrifice.

## Composition — the Altimeter reads the levels, the Tally pays for the sacrifice The Tally (the recursive-sacrifice-with-receipt line) presupposes the level conflict is already seen; it logs and floors the sacrifice (Threshold guard, recorder ≠ beneficiary, graduated cap). The Altimeter is the altitude-structure that the Tally's "greater good" silently needs — it answers how high (which altitudes are in tension, and which governs), the sibling of the Tally's whose (Wren's delta-read: cost-bearer ⊇ good-decider). One cross-ref each way; zero overlap. > Cross-ref status (in-flight, S11.2136): the Tally convention is mid-seat on a peer branch (S11.1944 spine-Pull / 11.1846 seat); the reciprocal Tally → Altimeter cross-ref is OWED until the Tally convention lands. This carrier names the composition now; the Tally's carrier picks up the back-reference at its seat.

## What it is NOT - Not an engine / not a stored structure. There is no goal database, no saved level-tree. The choss the operator's framing invites — a "Goal-Maps Engine" — is the numerology trap; cut by design. The Altimeter reads; it stores nothing. (Nyx's catch: a multi-level goal store is a generator of self-justifying altitude-shifting — "I was serving the higher goal" is the oldest cover. A read with an exogenous apex cannot self-certify the way a generative drive could — Sable's termination point.) - Not the Loupe. The Loupe (Report Convention) is a report's scope — one-bit ↔ whole-system, the zoom of a retrospective answer. The Altimeter is live intent-altitude in a forward decision. Distinct objects; named to stay distinct (the Loupe/Lens near-collision discipline). - Not Crow's Nest. Crow's Nest assesses whole-system methodology state "from altitude." The Altimeter reads one decision's goal stack. Different altitude, different object. - Not a new drive. A drive is generative and a witnessed commitment (Sol). The Altimeter is a read — the lightest constitutional shape. The system did not gain a drive; it pointed an existing law (Recursion) at a new axis and added a thin lens to read it. - Not the 4Quad explorer. The UAST 4Quad recursive question structure (workshop corpus) is a general idea-explorer, not goal-specific. It and the Altimeter are both facets of the Recursion law (as is the Block Principle's RG-fixed-point) — kin by the one law, not folded into one tool.

## The honest ceiling

Loop MMT™ · The Altimeter v1 · the read of a goal's altitude · the Recursion law on a new axis (intent-altitude) · apex = the constitution · reads the levels; the Tally pays for the sacrifice · visibility, not immunity · © 2026 Shea Gunther · New Gloucester, Maine · CC BY-NC 4.0