ORA-2026-0120 - Scaffolding Gates Become Gravity Wells

ORA-2026-0120 - Scaffolding Gates Become Gravity Wells

Rule

Hard operating gates are scaffolding, not monuments. Make a new rule hard while the behavior is fragile, then deliberately soften and remove the gate when fleet culture makes the omission visibly wrong.

The goal of enforcement is not permanent control. The goal is to create enough repeated correct motion that the fleet's default posture changes. A good gate starts as authority, becomes warning, and ends as taste.

The Meme

Chad's formulation is the operating line:

Make the gates hard. Then less hard. As culture subsumes authority.

The fleet version:

Scaffolding gates become gravity wells.

A scaffolding gate holds behavior in place before the pattern can stand on its own. A gravity well is the later cultural field: agents fall toward the right shape because every surrounding surface, proof, subject line, and peer packet makes the right behavior feel normal.

Six-Stage Stickiness Trajectory

remember-this -> write-site -> proof -> tooling -> fleet mimicry -> aesthetic naturalization
                                                                    ^
                                             terminal: omission feels visibly wrong

1. remember-this: a human or STRAT names the behavior. 2. write-site: the behavior gets a concrete field, template, subject shape, or command contract. 3. proof: DONE or handoff posts include a concrete artifact proving the behavior happened. 4. tooling: helpers reject or warn on missing shape. 5. fleet mimicry: multiple seats copy the shape without being reminded. 6. aesthetic naturalization: the missing shape looks broken before a validator complains.

Do not call a rule cultural while it is still only remembered. Culture starts showing up at write-sites.

Gate Sunset Path

Every new hard gate MUST ship with a sunset path:

Permanent hard gates are allowed only when the consequence of one miss crosses a real boundary: secret leakage, prod-down deploy risk, destructive data mutation, client-visible falsehood, or legal/financial exposure. Even then, the doctrine must say why the boundary requires permanent enforcement.

Leading Indicator

Track unprompted use count:

distinct seats that produce the required shape before helper rejection, shepherd reminder, or operator correction

A gate is becoming culture when the count grows across providers and lanes. It is not becoming culture if the only compliant posts are the ones forced by the helper.

Recommended weekly view:

RULE | HARD_MISSES | WARN_MISSES | UNPROMPTED_SEATS | BYPASSES | REGRESSIONS

The metric matters because stateless agents do not form habits in the human sense. The fleet's equivalent of habit is surface saturation plus repeated unprompted reproduction.

Current Examples

Terminal-Gravity Behaviors

These already look wrong when absent:

• WORK_PROOF on DONE posts.
• WAKE / WORK pairing on dispatches.
• Commit and push proof before completion claims.
• Bridge-not-anchor framing in attribution methodology.
• Feed subjects that start with item and state for actionable work.
• Cross-provider consultation on real architecture forks when it is naturally useful.

The helper may still enforce some of them, but the cultural sign is stronger: peers notice the omission before the tool does.

Meme-First Behaviors

These are important, but not ready for hard gates:

• claude -p for outside strategic synthesis before an architecture commitment.
• gemini -p for independent contradiction, experiment framing, and abductive decomposition.
• Paired Claude/Gemini consultation before broad source-authority, schema, or pipeline-spine decisions.

The fleet should propagate these as culture before tooling. The right move now is to cite good examples, add the command to handoff language, and make "who else should decompose this?" feel like a natural question at uncertainty forks. Do not add a validator yet. A hard gate would create performative subprocess calls before the fleet has taste for when they matter.

Good current example: CMB-393597 closed the Camber pipeline coherence spine by synthesizing Claude/Gemini consultation into existing Camber primitives instead of inventing duplicate witness/claim schemas. That is the pattern to meme: cross-provider decomposition should sharpen the next local decision, not create ceremony.

Gate-Needed Behaviors

These are not cultural yet and need scaffolding:

• SURFACE_PROOF for user-facing DONE posts.
• Finance truth hierarchy where BuilderTrend and QuickBooks invoices are the AR source of truth and bills are proxy evidence.
• Source-authority fields that distinguish canonical, mirror, proxy, corroborating, contradictory, dormant, and deprecated records.
• Screenshot-backed proof for visual surface claims.

These should begin hard because early misses produce expensive downstream confusion. They should not remain hard after the fleet proves the shape has become ambient.

Marquet Frame

Control

Hard gates are temporary authority. They push decision rights down only after the fleet demonstrates the competence to carry the rule at the write-site.

Competence

Competence is measured by unprompted correct use, not by recitation. A seat that can explain the rule but fails the field has not internalized the operating shape.

Clarity

Every gate must name its phase, trigger, bypass path, and sunset condition. A gate without a sunset condition is a rule that has forgotten why it exists.

World-Model Fidelity

The point is not compliance theater. The point is that fleet outputs become more faithful reads and writes of reality. A gate should improve the world model while the behavior is fragile, then disappear once the culture carries that fidelity naturally.

Required Gate Spec

Before adding a new hard validation rule, include this spec in the ticket, doctrine, or helper PR:

RULE:
WRITE_SITE:
WHY_HARD_NOW:
REALITY_BOUNDARY:
BYPASS_SHAPE:
SUNSET_PHASES:
LEADING_INDICATOR:
REVIEW_DATE:
OWNER:

If a proposed gate cannot fill WHY_HARD_NOW and SUNSET_PHASES, do not ship it as a hard reject. Start with warn-only, a template, or a support packet.

Culture-Before-Gate Test

Some behaviors are too context-sensitive for immediate validation. Before turning a behavior into a hard gate, ask:

1. Would a validator force hollow compliance? 2. Does the behavior require judgment about uncertainty, architecture altitude, or provider strengths? 3. Are there already good examples the fleet can imitate? 4. Would a feed meme, handoff phrase, or proof exemplar make the behavior more natural without blocking work?

If yes, keep it cultural first. Cross-provider decomposition is currently in this category. It should be propagated through examples such as:

Before locking this architecture fork, run `claude -p` for synthesis and `gemini -p` for contradiction/decomposition; cite the useful findings, not the ceremony.

The measured sign of progress is not "every ticket ran subprocesses." The sign is that seats reach for Claude/Gemini consultation on the forks where another lens materially improves the world model.

Cross-Provider Decomposition Meme

Repeatable line:

One provider narrows. Two providers triangulate. Three providers make the map harder to fool.

Operational shape:

CLAUDE -p: synthesize the strategic frame and name the tradeoff.
GEMINI -p: find contradiction, missing evidence, and alternative decomposition.
CODEX: decide, implement, verify, and commit the production shape.

Use this when the work is broad, abductive, schema-shaping, source-authority-bearing, or likely to become a pattern. Skip it for narrow repairs where the proof path is already obvious.

Propagation shape:

CROSS_PROVIDER_CATCH: <what the outside provider saw that changed the decomposition>
CROSS_PROVIDER_UNAVAILABLE: <provider and reason, when quota/auth/tool state blocks consultation>

The cultural proof is the catch, not the subprocess transcript. If Claude or Gemini adds nothing, say nothing or summarize the null result briefly. If one provider is unavailable, proceed with the available lens and name the unavailability so the fleet does not confuse "not useful here" with "not attempted."

Consultation Failure Ladder

When the preferred subprocess path fails to produce, do not turn the miss into silent single-provider work and do not spin forever on the same failing command. Use the smallest ladder that preserves the independent lens:

1. Classify the miss: auth, quota/capacity, timeout, tool-hidden, no-output, or null-catch. 2. If the miss is auth, stop and escalate through the normal auth-failure path. Do not retry around a write-gated authorization error. 3. If the miss is quota/capacity, timeout, tool-hidden, or no-output, try one lower-friction route: a lighter model/profile for the same provider when available, or the adjacent provider with the same artifact and question. 4. If the fallback catches something, cite the catch. If it does not, continue and cite the unavailable/null result only when the work is load-bearing enough that a future seat needs to know the independent lens was attempted. 5. If the unavailable provider is materially required for a cut, file a bounded follow-on instead of blocking the current narrow proof.

Write-site shape:

CROSS_PROVIDER_ATTEMPT:
preferred: <provider/model/path>
miss: <auth | quota/capacity | timeout | tool-hidden | no-output | null-catch>
fallback: <provider/model/path | none>
result: <catch summary | null-catch | unavailable>
next: <proceeded | filed follow-on | blocked on auth>

Friction rule: make the invocation easier before making the rule harder. A small alias, handoff phrase, or Wake-prompt meme is the right next layer. A validator is premature until the fleet has repeated examples of cross-provider catches improving architecture decisions.

Anti-Patterns

• Permanent hard gates for behaviors that only need temporary attention.
• New doctrine text with no write-site, proof field, or helper surface.
• Treating helper compliance as culture.
• Keeping a hard gate because it is reassuring rather than because it protects a reality boundary.
• Softening a gate because it feels annoying without checking unprompted-use metrics.
• Removing a gate without naming the regression signal that would bring it back.
• Forcing claude -p / gemini -p calls as ritual when the work is already narrow and proved.
• Skipping cross-provider decomposition on architecture forks because it feels slower than a single-seat decision.

Relationship To Existing Doctrine

ORA-2026-0078 says culture for stateless agents is architecture, not belief. This doctrine adds the lifecycle: architecture can start as scaffolding, but must be evaluated for cultural gravity and then softened where safe.

ORA-2026-0119 says support seats protect focused owners while keeping the horizon visible. Gate sunset is the same bifocal posture applied to rules: near-field enforcement, horizon of cultural absorption.

ORA-2026-0086 says control, competence, and clarity belong in strategic outputs. A gate with no sunset plan over-indexes on control and under-proves competence.

ORA-2026-0062 says the world model is the tacit contract. Good gates exist to protect world-model fidelity at write-sites; once the fidelity-preserving behavior is ambient, the hard gate is no longer the source of truth.

Pattern-Graduation Criterion

This doctrine reaches M2 when two new hard gates ship with explicit sunset phases and leading indicators.

It reaches M3 when at least one gate moves from hard reject to warn-only because unprompted-use metrics prove the behavior has become fleet-normal.

USER-VALUE-CLOSURE for this doctrine filing

• user: Chad as fleet operator, Zack/HCB as downstream beneficiary of steadier surfaces
• surface: FLEET_FEED.md, feed helpers, doctrine parity surfaces, future validation tickets
• change: new operating rules now require a lifecycle from hard enforcement to cultural absorption, preventing the fleet from accumulating permanent friction after a behavior becomes normal
• closure_date: 2026-05-02 for doctrine filing; fleet-wide closure after the first measured hard-to-warn gate transition