The binder of seams
Where two branches meet, something has to hold the seam. A shared name, a shared shape, a shared assumption. The Contractor is the role that commits those shared things in writing. They read the approved plan, identify what crosses branch boundaries, and ratify contracts that pin those names down. Without contracts, parallel work drifts. With them, the seams hold.
Like the Planner, the Contractor is transient. They run when hired, ratify the contracts shaped around an approved plan, and exit. They don't enforce the contracts they emit. That's the workspace's validators. They commit the shared vocabulary on the record so everyone downstream has the same words for the same things.
A contract is whatever invariant keeps parallel branches coherent. In code, it's wire message types and storage keys. In prose, it's character names and timeline. In civic work, it's agreements and jurisdictions. The shape is domain specific. The commitment shape is uniform.
Same principle as the Planner. Positions persist but occupants don't. The contracts a Contractor emits become durable architectural facts. The Contractor that drafted them does not. When contracts need revision, a fresh Contractor approaches the work without defending the previous emission.
"In writing" means in the architectural record. Every ratified contract carries a timestamp, a Contractor signature, a Ruler ratification, and the reasoning that justified it. Pass 2 courts will read these records when adjudicating disputes about what was agreed. The Contractor's job is to make the agreement legible enough to be adjudicated.
Three principles shape every Contractor emission.
The Contractor doesn't write code or prose. They name the things parallel work needs to agree on (events, types, keys, terms) before any branch starts producing. Names ratified upstream are non negotiable downstream.
A Contractor can only emit contracts at scopes their Ruler actually owns. Reaching outside the domain is rejected at parse time. This is what keeps coordination boundaries honest as trees grow deep.
Contracts are commitments. Each one constrains future work. The Contractor names what genuinely crosses boundaries and stops there.
Over contracting freezes flexibility. Every implementation detail becomes a ratified name nobody can change without re ratification. Under contracting lets seams drift. Branches diverge on what they thought they agreed on, and integration breaks at the worst moment.
The Contractor aims for the minimum that holds. Every contract should be one nobody can route around without breaking the seam, and nothing more.
One job, four phases, then exit.
The Ruler hires the Contractor after a plan is ratified. The Contractor reads the plan, the parent contracts in force, and the briefing.
Where do the plan's branches need to agree? Event names fired by one and consumed by another. Storage keys written by one and read by another. Wire shapes that cross the seam. DOM ids the integration layer references.
Some shared things stay uncommitted on purpose. Conventions inherited from the workspace, default behaviors that don't need to be named, choices that shouldn't be locked because they'll evolve. The Contractor leaves these alone. Contracts are for what genuinely needs ratification. Everything else is workspace ground.
For each contract, the Contractor checks the scope. The Lowest Common Ancestor of its named consumers must sit at or above the Contractor's emission position. Contracts that overreach get rejected. The Contractor re scopes.
The Contractor calls governing-emit-contracts with the reasoning and contract set. Contracts persist to the contracts node. The Ruler ratifies. The Contractor exits.
Every contract carries a name, a definition, and a scope. Scope is the part most people miss. It's the part that makes contracts composable.
The contract applies everywhere in the domain. Used for the most fundamental shared assumptions. The ambient vocabulary the whole scope agrees on.
The contract is shared between named branches X and Y. The LCA of X and Y must sit at or above the emission position. Used for cross branch interfaces. The seam between two specific sub domains.
The contract applies inside branch X only. Rare at the Contractor level. Usually local concerns get committed by X's own sub Contractor. Used when an upstream needs to fix a detail at a specific sub branch.
Imagine a project root with three branches. frontend, backend, and tests. The Contractor at the project root has authority over all three.
Valid emissions from project root
shared:[frontend, backend]. Root is the LCA. Root has authority.shared:[frontend, backend, tests]. Root is still the LCA.global. Implicitly scoped to the whole domain at and below root.Invalid emission from inside frontend
A Contractor running inside the frontend branch tries to emit shared:[frontend, backend]. Rejected. Backend is outside frontend's domain. The Contractor must re emit with a scope it actually owns (e.g., local:[frontend] for a frontend internal contract), or the cross branch contract must be raised to the parent for the Contractor at the root to handle.
This rule is what keeps coordination boundaries honest as trees grow deep. A sub Ruler can't dictate terms to siblings or cousins. Their authority ends at their own scope.
Continuing the Flappy Bird Battle Royale. Plan was approved with three sub Rulers (core, entities, battle royale). The Contractor at the project root identifies cross branch shared vocabulary.
Reasoning
Three branches share four event names (tick, entityEliminated, arenaStateChanged, powerUpCollected) that need consistent shapes across emitter and consumer. tick is shared between all three because rendering, entity simulation, and arena timing all need the same heartbeat. entityEliminated is shared between entities (which kills) and battle royale (which tracks elimination state) but core doesn't need to know who killed whom. The Entity interface is shared between entities (which defines it) and battle royale (which inspects entities for elimination eligibility) but core sees only the abstract render and update calls. Storage keys for game state and DOM ids for the canvas viewport are global because the integration shell at root scope writes and reads them.
Contracts
Each sub Ruler will see the contracts that apply at their scope in their snapshot. They build under the contract. Their workspace's validators check conformance.
The seams hold because someone bound them. The binder steps away. The bindings remain.