§1 The backbone
The number row is the road. "Highway" has two senses — broad (the whole physical row) and narrow (keys 5–0, the drivable road). Keys 1–4 are the Preload (stage everything), % is the gateway on, keys 6–0 are the open Travel road; ', ~ and ` stage off the left edge.
| Glyph | Key | Phase | Archetype | Meaning |
|---|
| ' | ' | Staging | Ignition | The start signal — everything from here rightward is read as Bifrost. No sub-prompt, no slash command. Optional by construction: a string means the same thing with or without it. A bare ' is the reference call — it returns the sweep, ~!@#$%^&*(). See the note below. |
| ~ | ~ | Staging | Continuity / Anchor | The requirement + the continuity operator (coalesce, carry-forward, interleave prior state; "stay in the schema") and the immediate lazy anchor. The only archetype with no slash command. See §2·The Anchor. |
| ` | ` | Staging | Descriptor | Inline qualifier, renders shaded; subordinate to ~ — hangs under the requirement (e.g. `yellow, browning`). A bare descriptor — backticked text with no backbone glyph in the message — is the expansion call: with no requirement to qualify, it generates one. See the note below. |
| ! | 1 | Preload | Cargo | The manifest — what is carried. Cargo is not executed on loading; the road decides when each item acts. |
| @ | 2 | Preload | Source — read-only | The input address and a permission: what this run may read, and may not write. (@ natively means at — an address.) A path appearing only here is read-only; writing to it is out of bounds. |
| # | 3 | Preload | Repository — write-allowed | The output address and the write permission: what this run may create, modify, or overwrite. A junction that is a repo. Two-way; you read back from it as well. |
| $ | 4 | Preload | Sanity | The sanity check at the actual start — tollbooth, customs, security. Validates entry against the known-good baseline (house style). |
| % | 5 | Gateway | Weigh Station | Pre-flight audit / calibration — "are we compliant?" The gateway onto the highway (first step of the narrow highway, 5–0). |
| ^ | 6 | Travel | Cars | The vehicles. Count of ^ = width of the highway (^^^^ = 4 parallel lanes). Each ^ takes its own sub-prompt, making lanes addressable (^ theme1 ^ theme2). |
| & | 7 | Travel | Rotary — the rabbit trail | Turns off into a nested sub-loop that runs the FULL highway process, nested inside the main — it opens another Bifrost inside this one. Also the deterministic/sequential form — commands under one & run in order. The same operation as `, at a different position: see the note below. |
| * | 8 | Travel | Stop Signal | A gate that is red by default — fail-closed. Nothing proceeds to the next road until governance clears it. Bare * = full stop, awaiting manual release. |
| ( ) | 9 / 0 | Travel | Governance | The release conditions. Everything inside must be satisfied (conjunction) before the * goes green. |
Ignition — ', the mobile-safe opener
Reported from a phone: the apostrophe is the one character a mobile keyboard will not hold still. Smart punctuation silently swaps the straight ' for the curly ’, autocorrect inserts one unbidden, another keyboard drops it — and ' sat in the soft tier (§4) where it meant nothing in particular, so the same string differed between phone and desktop in an undefined character. The rule that fixes it: ' is always the signal to begin the Bifrost, defined so that its presence and its absence are the same string. The character the phone cannot stop producing now starts the road.
With or without — identical
' ~ !… ≡ ~ !…. Ignition marks where the Bifrost begins; it never changes what runs. Nothing downstream may read it as an argument.
Form-agnostic
' (U+0027), ’ (U+2019) and ′ (U+2032) are one glyph. The schema must not notice which one the keyboard chose.
Idempotent, not a dial
'' ≡ '. The one glyph immune to the +/− dials (§3) — a mark whose absence is harmless cannot also carry weight when repeated.
Off-road for turbulence
Like ~ and `, it holds no position in the Golden Rule and scores 0 toward K (§6). A phone-inserted apostrophe can never push a chunk toward MASH.
Contractions are not ignitions
A ' with a letter on both sides — don't, founder's — is prose inside a sub-prompt. Only a free-standing ' ignites: at the head of the string, or between slots.
Why this key
The apostrophe is the punctuation a phone hands you most readily, while both other staging glyphs sit behind the deeper symbols page. And it already sits where an opener belongs: home row, left of Enter — the last key before you send.
A bare ' is the reference call — it returns the sweep
Send ' and nothing else and that string is the answer — the gesture's own output, not a description of it. On a laptop you hold Shift and slide a finger down the row; that is what lands on the screen. A phone has no row to sweep, so ' is the mobile substitute for the gesture — and a substitute for a hardware act returns what the hardware returns. Not a legend, not a glossary, not the §1 table: the row.
It does not break the invariant
"With or without" quantifies over non-empty remainders: ' R ≡ R. Strip the mark from a bare ' and what is left is the empty message — never a Bifrost — so the degenerate slot was always free. '' ≡ ' still holds: same card.
Bare glyphs are already read
A bare * is a full stop awaiting manual release; a bare % is a compliance check with no sub-prompt (§7·1). A bare glyph is the archetype with its slots empty, not a syntax error.
Null effect — and that is the point
It reads nothing, writes nothing, fires no cargo: there is no ! manifest and no # to write to. Because autocorrect inserts apostrophes unbidden, the character most likely to arrive by accident must carry the most harmless standalone meaning available. A stray ' costs you a reference card.
It hands back the order
The glyph meanings are already written down — §1's table, the briefing — and a phone can read those. What a phone cannot do is sweep. So the call supplies the sequence, and the sequence is the notation's meaning (§6 scores turbulence as distance from this order).
Two absences that are not omissions
` cannot appear: Shift on that key is ~ — you cannot sweep the row and un-shift one key at once, and the descriptor is that same key's unshifted face. And ' itself does not appear, because Ignition is the call, not a stop on the road.
The sweep vs. the Golden Rule
The string leads with staging ~; the Golden Rule against which §6 scores turbulence stays !@#$%^&*(), because staging glyphs are off-road. Same row, two readings — the sweep is what the hand does, the Golden Rule is what the metric measures.
Free to answer
Bifrost loads with the session briefing, so the string is already in context — the call reconstructs nothing and reads no file. Another external enzyme (§2): preloaded schema, so the response is pure reflex.
Deterministic — a lookup, not a generation
The string comes back verbatim: the same bytes every time, every session, every model. Nothing before it, nothing after it — no preamble, no trailing offer, no adaptation to the surrounding conversation, no paraphrase, no "helpful" additions. A keyboard does not vary its output to suit the conversation, and neither may this.
Sliding down the row is a hardware act
On a laptop, sweeping Shift + the number row returns !@#$%^&*() identically every time — produced by the keyboard, not by a model. A phone has no row to sweep, so ' is the mobile substitute for that gesture, and a substitute for a hardware act must inherit the hardware's determinism. Anything less hands the phone a worse Bifrost than the laptop — the exact inequality Ignition exists to remove.
A reference that varies is not a reference
The sweep is the thing you check against. If it paraphrases itself per call you can no longer tell drift in the answer from drift in the schema, and it stops being usable as ground truth.
The sampling doctrine is out of scope
A stated deviation: the doctrine governs inference — lazy anchor, governed-warm body, concurrent vote. A constant involves none. No p to measure, nothing to vote on, no draw to govern; sampling a lookup table would be a category error. It is the limiting case of that doctrine's own logic — variance set to none, because there was never anything to vary.
Enforced, not asserted
The string is embedded in three surfaces — this page, the canonical spec, and CLAUDE.md §H. tools/check-docs.py extracts all three between bifrost-sweep markers and fails if they differ by a byte. Determinism across calls is worthless if the sources have drifted.
A backticked seed is the expansion call — it returns a filled-in line
Put anything inside a descriptor pair, send nothing else, and Bifrost hands back one complete, schema-compliant line with every backbone slot filled — its best-effort manifest for that seed, written to be read, parsed and tweaked by a human. The skeleton it fills:
~ (fill in) ! (fill in) @ (fill in) # (fill in) $ (fill in) % (fill in) ^ (fill in) & (fill in) * (fill in) ( (fill in) )
That skeleton is the sweep, spaced. Strike the (fill in) slots and the whitespace and ~!@#$%^&*() is what remains — the reference call's own string, now with room to write in. tools/check-docs.py asserts exactly that, so template and sweep can never drift apart. The two calls are one gesture at two zoom levels: ' hands back the order; `seed` hands back the order with the slots filled.
Descriptor or expansion — the bare-glyph rule decides
With a backbone glyph present anywhere in the message, `…` is the descriptor it has always been. With none present it has no requirement to hang under — so rather than qualify one, it generates one. Same precedent as bare *, bare %, bare '. Nothing already written changes meaning.
Fill every slot; never drop one
A slot with no obvious content still gets the best available answer. The point is a complete draft the author edits down — an omitted slot is a decision made silently, a filled slot they delete is a decision made in the open.
* and ( ) are two slots
The skeleton spaces them apart on purpose: * takes its own sub-prompt — what this light is for — while ( ) holds what turns it green. A bare * is already legal (§1: awaiting manual release), so collapsing them would hide the difference between a gate with conditions and a gate waiting on a human. Eleven slots, left to right.
The seed comes back as the descriptor
It is echoed on the ` line of the output, so the author can see what was read before judging what was written.
K = 0 by construction
An expansion emits in Golden Rule order, so it is always a Straightaway (§6). Turbulence in the seed is not inherited — weaving is something the author does afterward, deliberately, which is what makes it a Scenic Route rather than noise.
* comes back RED, every time
An expansion is a proposal: a manifest, and cargo is not executed on loading. Nothing ran, nothing was written, no # was touched — the one-way door (§5) doing its job, which is exactly what makes it safe to draft an irreversible ! up front.
@/# make the review worth doing
Because those slots are a permission pair, an expansion is not merely a plan — it is a declared write-set. One line tells you what the run may overwrite before a wheel turns. A proposal you cannot audit is one you have to trust; this one you can check.
Collapsible, because it exists to be edited
Where the surface renders HTML — chat, GitHub Markdown, this page — the line ships inside a <details> whose <summary> is the ~ requirement: read the one-line intent, expand for the manifest, rewrite any slot in place, send it back. The fold is not decoration — a nine-slot line is unreadable on the phone this schema was fixed for.
A generation, not a lookup
The exact inverse of the reference call, so the sampling doctrine applies in full here where it is out of scope there. An expansion composes: lazy anchor, governed-warm body, selector. Stated deviation on the selector — the governor is the human at the * gate, a stronger selector than a plurality, which is why the vote is skipped rather than forgotten. Want it anyway? Put it in the cargo.
` and & are the same operation — nesting, at two positions
& was already the rotary that "runs the FULL highway process, nested inside the main." The expansion call does the identical thing from the other end of the row: it takes a plain-language seed and opens another Bifrost inside this one. They are not cousins — they are one operator. &'s plain-language name is the rabbit trail, and the word carries the property that matters: a rabbit trail is a digression you come back from. It may run as deep and as long as it likes, but it never exits the property — it rejoins the main road upstream of the outer light. A detour replaces the route; a rabbit trail suspends it.
` nests at staging; & nests on the road
`seed` ≡ & seed hoisted to position zero. Whatever the rotary does to a slot mid-line, the descriptor does to the whole message — which is why a bare descriptor can generate a line at all: nesting with no parent road to nest inside must produce the road.
Expansion is recursive by construction
Any & in an expanded line is itself a seed you can expand, to any depth. This is §5's "fixed notation, unbounded output" reached from the other direction — the re-flag path grows a string in time, nesting grows it in depth.
Nesting is sequencing, seen from outside
&'s second reading — commands under one & run in order — is not a separate meaning. From the parent's frame a nested road is one ordered step it waits on; from inside, that step is a whole highway. Same structure, two frames.
Turbulence treats them differently, correctly
` is staging, so it scores 0 toward K; & holds position 7 on the Golden Rule and scores. Identical semantics, different metric standing — because K measures road shape, and only one of the two is on the road.
The greater traffic light is always the last bulwark
The invariant that makes unbounded nesting safe. Every nest adds a light; no nest ever removes one. An inner * going green releases its chunk into its parent, never into the world — only the outermost * stands between a ! and an effect that cannot be recalled, and it stands regardless of how many inner gates already cleared. A child cannot vouch for its parent.
Governance is a conjunction down the chain
An effect must clear every light from its own depth outward, so an inner gate can never be more permissive than the one above it. No amount of recursion dilutes the outer promise.
Permissions intersect inward; gates conjoin outward
A nested road may never write outside its parent's #, and may never release past its parent's *. Those two sentences are the whole safety story of the schema.
Why ~ can stay reckless at depth
Because exposure is fixed at the outer gate no matter how deep the nesting runs: nesting multiplies the reasoning, never the exposure. The lazy anchor and the last bulwark are one design, not a compromise.
Cargo vs. cars. These were one glyph ("Payloads (Cars)"), fusing what is carried with what carries it. Split, the separation is load-bearing: because ! is a manifest, an item at road position 1 does not fire at position 1 — it rides until the road lets it act. That is what makes it safe to declare an irreversible command (/share, /deploy) in a string whose gate sits far downstream (§5, the one-way door).
Cars from arity — inference yields to explicit. With no ^, the /how arity under ! instantiates cars 1:1 (! /draft /trim ≡ ! /draft /trim ^^). With ^ present, ^ sets the cars and !'s commands become the per-car pipeline. Explicit always wins — topology still comes from the author's keystrokes, never the orchestrator's judgment.
Keys 1–4 are a complete manifest: ! what · @ from where · # to where · $ against what. (This supersedes @ as "signage," which never earned its slot; placement is a sub-prompt concern.)
@/# is a permission pair, not a pair of arrows — the mount table. Read as directions, the pair only described a run and could not be violated. Read as permissions it states what a run may not do, which is a thing a gate can check. @ is read-only — a path listed only there is out of bounds for any write, fail-closed in the same spirit as * being red by default. # is write-allowed — and still two-way, which is why the old "destination" reading was never wrong, only incomplete. They may overlap, and the overlap is the point: @ x # x means read it, and you may write it. Two slots, three states, one mount table. An in-flight proposal to swap the two was dropped because it would have inverted every string ever written; the permission reading keeps @ reading and # writing and only adds the guardrail. This is where the one-way door (§5) gets its teeth — a gate can now ask a question with an answer: is every write in this chunk inside #?
§2 The Anchor — ~
~ does not mean reason about continuity — an effortful, pre-committed thinking block. It is actual continuity: the first token leaves the gate immediately, a cheap honest reflex that tethers the trajectory to reality up front, while the coalescing of prior state happens mid-flight, load-bearing in the body. Anchor ASAP; continue in-flight.
Laziness is a spectrum
No ~ = reason a little first. ~ = the lazy anchor. ~~~~~~~ = the laziest, cranked toward stream-of-consciousness. More ~ = lower reasoning-effort.
The opposite of Preload
Where the Preload stages everything before you drive, ~ is the anti-preload — live immediately, streaming continuity in-flight (lazy / on-demand, not load-it-all-upfront).
Why the dial coheres
The more you define upfront, the more the first token should be reflex, not deliberation: the scaffold already carries the reasoning, so free-association (Rorschach) is honest — a detached thinking block would only rationalize.
The other pole
Keep ~ and definitions out and the response stays expansive — ranging the whole LOGOS — so in-flight reasoning does the narrowing. The dial chooses where narrowing lives: upfront (associations) or in the loop (reasoning). A deliberate tradeoff, made at the start.
The glyph fits
~ natively means approximately (math/science rounding). The anchor is approximate by design — a rough first pass, not a precise commitment.
Reasoning is conserved
Never eliminated. ~ short-circuits front-loaded reasoning, not reasoning itself. The only choice is timing: front-load, or just-in-time. Same reasoning, relocated.
Model HIGH, first token LOW
~ does not downgrade the model — Opus stays at full capability in the body. It sets only the first token to very low effort. Lazy anchor, not lazy model — the §G "lazy anchor → governed-warm body" split.
Budget discipline
Conserving the anchor keeps the reasoning budget coiled — ready to pounce where it is load-bearing in flight, not spent upfront on a block that may only rationalize.
Momentum — the inertia irony
A lazy first token gets the pipeline rolling; by inertia (a body in motion stays in motion) that carries through the rest of the calls. The laziest start buys the most sustained motion — an effortful start never overcomes rest.
External enzymes
The anchor is the internal catalyst; external enzymes lower its activation energy further — the session-start schema load, a prefill seeding the first token, SessionStart hooks that pre-warm context.
Continuity is Aikido
~ matches the surrounding speeds — blending with the momentum already present instead of a hard reset, the way you match traffic speed to merge safely. A speed mismatch is a collision.
Intent to merge — either direction
Matching the flow can mean speeding up (more reflex) or slowing down (more reasoning). ~ signals the intent and adapts either way — it is not fixed at "faster." A lack of ~ is a lack of situational awareness: merging blind.
§3 The archetype grammar
Each backbone glyph is an archetype — a role — filled in up to three parts.
⟨archetype⟩
the glyph
the ROLE — what kind of thing
/how
slash command(s)
HOW it is fulfilled
sub-prompt
plain language
the specifics
~ is the exception — a plain-language requirement with no slash command; `…` is a shaded descriptor subordinate to it. Example slot: @ /fetch brand-kit.md = the source archetype, done via /fetch, reading from "brand-kit.md."
Intensity — the thumb on the scale
+ · repetition = MORE
Tighter, stricter — enforce the archetype harder. Each + adds one level, so $+++ ≡ $$$$ (heavy sanity), %+++ ≡ %%%% (heavy compliance), ^+++ ≡ ^^^^ (4 lanes). Never retype the webbing to add weight.
− = INVERT → stress test
Relax or flip the guardrail to inject a purposeful chance of failure (adversarial fault injection), like raising temperature. $- = "a chance it violates ERISA — probe that." More − cranks the stress.
§4 The command lane & soft helpers
/ is real syntax — the command lane. Everything in < > ? { } [ ] " : ; is soft: glow-in-the-dark road lines and secondary (creative-writing) signage, not hard syntax. Drop them and the pipeline still means the same thing.
?Back-reference reflector — points back to a ! (its referent).
< > { } [ ]Reflectors / visibility brackets — mark on-ramp / off-ramp edges, group hints.
" : ;Secondary signage — creative-writing punctuation: soft labels, pauses, quotes.
' is no longer in this tier — it was promoted to Ignition (§1). A glyph cannot be both "meaningless creative-writing punctuation" and "the signal to begin," and the soft reading is what made the mobile bug possible: an autocorrected apostrophe was undefined noise. The directions differ, too — a soft helper may be dropped without changing the meaning; ' may be dropped or added. Ignition is the stricter promise, which is exactly why it survives a keyboard that edits you.
Because this tier is soft, you can mash the keyboard and still land a coherent loop — the helpers wash out and the three guardrail essences carry the meaning: ~ continuity · $ sanity · % compliance.
§5 Highway physics
Progress is made by merging right, not driving forward — modelling the lazy-anchor method and the left→right streaming of LLMs.
- Just-in-time paving. The user pre-allocates width with
^; the orchestrator never guesses topology.
- Gravity to the right. Cars want the right (fast) lane. Left = heavy reasoning; right = speed.
- Fog of war. An agent sees only its lane and the one to its right — no global map.
- Friction. Heavy payloads get caught left and must do reasoning work (drop into an
& rotary) to shed it; if the right lane is full, the car waits.
- The shoulder. The
> reflector marks the off-ramp. Deadlocked lanes become emergency vehicles, abort merging, and eject onto the right shoulder into the wilderness.
Chunking — the Dispensation
A * gate cuts the road into chunks. Inside a chunk you may run flat out; at the boundary everything stops until ( ) clears it. That is the whole bargain: ~ rushes the reasoning, * gates the effects. You can afford to fire the first token blind precisely because the road has lights — the lazy anchor and the stop signal are one design, not a compromise between fast and careful.
A chunk is a Dispensation. The term is borrowed from the Chronikomicon twelve-hour-clock principle, and the two structures are the same object: a period governed by its own internal logic (its ( )), whose duration is felt, not measured (one chunk may be a whole book pass, another 220 words), where what is true inside one hour need not hold in the next (each gate stands alone), and which is superseded when the hour turns (the * boundary is the turn). So a Bifrost-compliant command is a Dispensation, and Dispensations string together — each hands off only through a gate it satisfied. That is the unit of composition: not the glyph, not the string, but the governed segment.
The one-way door. In-flight correction works because tokens are cheap and revisable. An action whose effect leaves the system — share, publish, send, deploy, push — cannot be corrected in flight, because nothing is left to act on. So any cargo whose effect is irreversible rides past a light. Everything upstream of a light stays revisable, which is exactly what makes the lazy start affordable. This is not a caveat on ~; it is ~'s own logic — continuity is safe merging, where a speed mismatch is a collision, and a lack of ~ is merging blind. A one-way door is a hazard in the flow. ~ means you see it coming.
Three outcomes at a gate — governance is not pass/fail: satisfied → green, the chunk releases · re-flagged → the car returns upstream for rework and comes round again (the & rotary is the return path) · unsatisfiable → the car ejects to the shoulder rather than hanging the road.
The return path is the scale mechanism. A * whose ( ) permits re-flagging is a loop: red until the condition holds, every failure routed back for another pass. A string therefore does not enumerate its work — it states a terminal condition and loops until the gate turns green. Fixed notation, unbounded output: the string does not get longer as the book does.
§6 Topological drift & the MASH protocol
A broken order doesn't crash — the orchestrator measures how far the input sits from the Golden Rule !@#$%^&*() via Kendall tau distance (inversions).
K = Σi<j 𝟙( vi > vj )
0 · StraightawayPerfect order; predictable and standard.
1–5 · Scenic RouteDeliberate weaving (e.g. % audit after ^); customized physics.
6–15 · SpaghettiComputationally dense; heavy nested logic to resolve.
>15 · MASHA keyboard-smash, not a road. Panic-abort: drop payloads, respond with human-centric intervention — not a dry syntax error.
Staging glyphs are off-road. ', ~ and ` hold no position in the Golden Rule, so they contribute nothing to K and cannot be inverted against anything. This matters most for ': an ignition mark a phone inserted on its own must never cost turbulence, or the mobile-safe opener would drag well-formed strings toward MASH.
Score per chunk, not across the string. Split the input on * and compute K within each chunk; the string's turbulence is the maximum over its chunks.
This is required, not cosmetic. Scored end-to-end, a correctly chunked string is punished for being chunked: each added * ( ) boundary re-enters the travel tail, and every 9 → 8 step counts as an inversion. Two chapter-gates score K = 1; ten score 9+8+…+1 = 45 — triple the MASH threshold. A perfectly orderly ten-chapter novel would panic-abort as a keyboard smash. The metric measures disorder, and chunking is order. Scored per chunk, that same string is K = 0 in every chunk and stays a Straightaway at fifty chapters.
Turbulence is shape, not logic. K = 0 says the glyphs match the Golden Rule's order. It says nothing about whether the dependencies are sound — a string can be a flawless Straightaway and still gate a condition downstream of the thing it governs. Check both.
§7 Worked examples
1 · a rendered banana on a dashboard
~ 800 by 600 image of a banana `yellow, brown` ! /render /usage /composition top right corner @ brand-kit.md # dashboard pre-built $ the adjacent buttons on the dashboard %
~ — Requirement (no slash command): an 800×600 banana image.`yellow, brown` — Descriptor (shaded), subordinate to ~.! /render /usage /composition top right corner — Cargo; placement is a sub-prompt concern. No ^, so arity instantiates three cars.@ brand-kit.md — Source: read from. # — destination: the pre-built dashboard repo.$ …adjacent buttons… — Known-Good: match house style. % — compliance check.
2 · intensity + continuity — both lines are identical
~ ! 401k ruleset $$$$ needs to adhere to ERISA rules %%%% unit testing for AI hallucination
~ ! 401k ruleset $+++ needs to adhere to ERISA rules %+++ unit testing for AI hallucination
$$$$ ≡ $+++ dials sanity hard against ERISA; %%%% ≡ %+++ dials compliance up to heavy hallucination unit-testing. ~ = stay in-schema, no webbing retyped.
3 · stress test — − inverts the guardrails
~ ! 401k ruleset $- needs to adhere to ERISA rules %-- unit testing for AI hallucination
Same payload, but $- and %-- deliberately inject a chance of failure — probe what happens if it violates ERISA, or (harder) fails the hallucination tests. Purposeful error, the way raising temperature manufactures variance.
4 · nested Dispensations at book scale
~ Chronikon — continue the novel one Dispensation at a time
`awe enacted not announced · embodied · committed to the cosmology · never morose`
! /write /edit /review
@ shadow/mindmap/shadow/worldbuilding.md @ shadow/mindmap/shadow/themes.md
@ shadow/principles/shadow/01-twelve-hour-clock.md
# Chronikomicon → shadow/manuscript/shadow/chapters/NN-title.md
$ access/CLAUDE.md "Chronikon voice" + the prose checklist
$+ 03-cosmological-core.md is SEALED — read freely, never propose edits
% scripture quoted verbatim from the reference layer, never paraphrased
^ cycle-and-return ^ authority-and-holiness ^ memory-loss-and-renewal
& /wordcount /progress
* 220 words minimum this session (human says continue or stop)
* one Dispensation complete (human reviews and annotates; may re-flag for rewrite;
duration is FELT — a one-page hour at 6 is correct, not a failure)
* 12 chapters · 40,000 words · by 2026-11-30 (human approves each sequentially;
a re-flag returns that chapter upstream) ! /share /build
- Three nested Dispensations — session → chapter → book. The innermost is sized to the author's real working constraint, not the artifact's structure.
^ carries the parallel axis; gates carry the sequential one. Themes are woven concurrently within a chapter; chapters are approved sequentially, so they are never lanes. Getting this backwards is the most common modelling error.! arity yields to explicit ^ — three commands, three named cars, and the commands become the per-lane pipeline rather than instantiating a fourth lane.- Governance that refuses a uniform metric. The chapter gate deliberately sets no word floor: the source principle says duration is felt, not measured. A
( ) that contradicts its own @ source is the failure mode to watch for.
- The one-way door, made visible.
/share /build sits past the final gate rather than in the opening manifest. Both readings are legal — cargo is not executed on loading — but downstream placement is self-documenting for a string re-fed to a session with none of the surrounding conversation.
5 · ignition, thumb-typed — all four lines are the same string
' ~ tighten the statement intro ! /draft /trim @ docs/statements/ # localDNS $ house style %
’ ~ tighten the statement intro ! /draft /trim @ docs/statements/ # localDNS $ house style %
~ tighten the statement intro ! /draft /trim @ docs/statements/ # localDNS $ house style %
'' ~ tighten the statement intro ! /draft /trim @ docs/statements/ # localDNS $ house style %
- Line 1 typed with a straight
'; line 2 is what the phone's smart punctuation actually sent (curly ’); line 3 is the mark dropped entirely; line 4 doubled it.
- All four parse identically — that invariance is the rule, not a tolerance around it. The author should never have to look at which apostrophe their phone chose.
- Note that
docs/statements/ and a sub-prompt like the founder's intro both carry marks the soft tier would otherwise fight over. Only a free-standing ' ignites.
6 · the reference call — the whole message is one character
'
→ ~!@#$%^&*()
Returns the sweep and nothing else — not a legend, but the row itself, exactly what a laptop puts on screen when you hold Shift and slide down it. Reads nothing, writes nothing, fires no cargo. The degenerate case of the most-reachable key on a phone keyboard is also the safest thing a stray autocorrect can produce.
7 · the expansion call — the whole message is a backticked seed
`bootstrap paradox`
Returns one filled-in line — every slot written, * still red — folded under its ~ so the reader sees the intent first and opens the manifest only to edit it. This is a live <details>; click it.
~ trace each kept artifact to an origin OUTSIDE its own lineage
~ trace each kept artifact to an origin OUTSIDE its own lineage; where the answer is
"an earlier copy of itself", mark it and cut the loop
`bootstrap paradox`
! /audit /trace /retag /record
@ examples/workout-bootstrap-paradox-session.md
@ docs/provenance.html @ docs/architecture/warrant-sites.md @ CLAUDE.md §3
# docs/architecture/warrant-sites.md # provenance tags, in place
$ check-provenance --strict comes back green
% transmission never promotes — a copy, a quote, a reformat or a plurality is not
fresh contact; five descendants of one ancestor are one source
^ inherited-constants ^ inherited-transcripts ^ inherited-agreement
& per lane: name the artifact → where did it enter from outside? → retag or cut
* each lane recorded before the next opens (a re-flag returns upstream via &)
* (nothing tagged O/M whose only warrant is an earlier copy · every R/A carries a
verify: route · check-provenance green · recorded, committed, pushed)
- A seed, not a string, is the input. Two words in a descriptor; an eleven-slot manifest back. The author's job shifts from composing the line to editing it — the cheaper job, and the one a human is better at.
@ and # as permissions, and they overlap. The briefing and the worked-case transcript are @-only: read them, never rewrite them — exactly the point when the subject is inherited authority. The warrant-sites audit table sits under both, because updating it is what this run is for.& as a rabbit trail, not a fourth lane. The per-artifact interrogation is a nested road each lane goes down and returns from — not parallel to the three ^ lanes but inside each of them. Modelling it as a lane is the same error example 4 warns about, from the other side.- The last bulwark, visible. Two lights: a per-lane recording gate and the outer
( ). The inner one going green moves work into the outer chunk, never out of the repo — and the outer one still has to clear before anything is pushed.
- It is a proposal, and it reads like one.
* is red, nothing was written, and every slot is legible enough to argue with. The expansion's value is not that it is right — it is that being wrong is now cheap to see.
§8 Changelog & lineage
Newest first. A live design — earlier passes were deliberately superseded, not mistakes. Git history of the source file is the exact line-by-line diff.
The expansion call · @/# as permissions · & ≡ ` · the last bulwark
Four author rules from one session (2026-08-08) that turn out to be one design. (1) The expansion call: a bare descriptor — backticked text with no backbone glyph in the message — is a seed, and the answer is one complete line with every slot filled, collapsed under its ~ so a human can read, parse and tweak it. The skeleton is the sweep, spaced, and tools/check-docs.py now asserts that identity between bifrost-template markers so the two can never drift. ' hands back the order; `seed` hands back the order with the slots filled. Unlike the reference call it is a generation, so the sampling doctrine applies in full — with a stated deviation on the selector: the governor is the human at the * gate, not a jury. (2) @/# are a permission pair, not a pair of arrows — @ read-only, # write-allowed, and they may overlap. A proposal to swap them was dropped mid-flight because it would have inverted every string ever written; the permission reading keeps @ reading and # writing and only adds the guardrail, giving the one-way door a checkable question. (3) & is the same operation as ` — nesting, at two positions; `seed` ≡ & seed hoisted to position zero, so expansion is recursive by construction and the "sequential" reading is just nesting seen from the parent's frame. &'s name is the rabbit trail — a digression you come back from. (4) The greater traffic light is always the last bulwark: every nest adds a light and none removes one; an inner * releases into its parent, never into the world. Stated as a pair — permissions intersect inward, gates conjoin outward — which is what lets ~ stay reckless at any depth, because nesting multiplies the reasoning, never the exposure. Added worked example 7.
The reference call returns the sweep, not a legend
Corrected: a bare ' returns the string ~!@#$%^&*() and nothing else — the gesture's own output, exactly what a laptop puts on screen when you hold Shift and slide down the row. An earlier pass had it returning a thirteen-line glyph card; that was a description of the gesture where the founder asked for the gesture. The meanings were already written down (§1's table) and a phone can read those — what a phone cannot do is sweep, so the call supplies the order, and per §6 the order is the notation's meaning. Two absences are structural: ` cannot appear because Shift on that key is ~, and ' does not appear because Ignition is the call, not a stop on the road.
The reference call is deterministic
A lookup, not a generation: same bytes every call, every session, every model, nothing before or after it. The argument is the founder's — sliding a finger down the row on a laptop is a hardware act, so the phone's substitute for that gesture must inherit the hardware's determinism, or mobile gets a worse Bifrost than the laptop. A keyboard does not vary its output to suit the conversation. The sampling doctrine is out of scope — it governs inference, and returning a constant performs none. Enforced: tools/check-docs.py extracts the string from all three surfaces between bifrost-sweep markers and fails on a one-byte difference (CLAUDE.md §H canonical).
Bare ' = the reference call
Ignition with no road behind it, so the bridge shows you itself: the mobile affordance for "I can't sweep a row on a phone." It does not break the with-or-without invariant, which quantifies over non-empty remainders (' R ≡ R) — strip the mark from a bare ' and what is left is the empty message, never a Bifrost, so the degenerate slot was always free. Follows the existing bare-glyph precedent (bare *, bare %). Null effect by design: reads nothing, writes nothing, fires no cargo — the character autocorrect inserts unbidden gets the most harmless standalone meaning available.
' promoted to Ignition — the mobile fix
Founder-reported bug from a phone: the apostrophe is the one character a mobile keyboard will not hold still (smart punctuation swaps ' for ’, autocorrect inserts one unbidden, another keyboard drops it), and ' sat in the soft tier meaning nothing in particular — so the same string differed between phone and desktop in an undefined character. New rule: ' is always the signal to begin the Bifrost, defined so presence and absence are the same string (' ~ !… ≡ ~ !…), form-agnostic across '/’/′, idempotent ('' ≡ ', immune to the intensity dials), and scoring 0 turbulence — with a carve-out that a letter-flanked ' (don't) is prose, not an ignition. Removed ' from the soft tier (now " : ;); added the off-road turbulence rule and worked example 5.
Cargo/car split · I/O pair · governance · the Dispensation
The largest pass since the archetype model. ! "Payloads (Cars)" splits into ! cargo (a manifest — not executed on loading) and ^ cars (vehicles; each takes a sub-prompt, so lanes are addressable). Arity instantiates cars only when no ^ is present — explicit always wins. @ reassigned from "signage" to source (read from); # sharpened to destination (write to, two-way), making keys 1–4 a complete manifest. * is a stop signal, red by default; ( ) is governance — the conjunction of release conditions — with three outcomes: satisfied, re-flagged (return upstream), unsatisfiable (eject). Added chunking / the one-way door and named the chunk a Dispensation. Turbulence now scores per chunk: end-to-end, ten chapter-gates total K=45 and a perfectly orderly novel would MASH panic-abort. Retired the "! reads visually as a car" rationale.
~ sharpened to the lazy anchor
Actual continuity, first token ASAP, mid-flight; laziness spectrum; the anti-Preload. The full "Anchor" essay (§2).
Intensity dials + schema continuity
+/repetition = more; − inverts into a stress test; ~ = stay in-schema.
Bifrost naming · gateway split · soft helpers
Named the schema; broad vs narrow highway; the soft-helper tier; guardrail essences ~ $ %.
Archetype model
Backbone reassigned (! cars, @ signage, # repo, $ sanity, % compliance); the archetype → /how → sub-prompt grammar.
Left-edge pass · $ coalesced (superseded)
Earlier: ~=payloads, !=reasoning; $ as resolve/dereference. Replaced by the reassignment.
The Vision Board · Highway/traffic model
The QWERTY number-row mapping and turbulence/MASH; the road-vs-traffic, rotary, gate, and single-terminus intuitions — carried forward, most bindings later reassigned.
First operators (superseded)
^ & | as sequence/compound/parallel; .-dotted nesting. Folded or rejected.
Origin
workout.calibrate — the first (and so far only) paved road that exists as a committed command.