/apportion

name: apportion
description: "One goal is about to be handed to an autonomous run: the user takes a plan of units with checks, accepted gaps and held judgments, seeing what needed settling first and what returns at the end."

Merismos Protocol

Apportion an autonomous goal into coarse execution units and derive each unit's completion conditions before the run begins: cut the goal at its evidenced seams so each unit fits one execution horizon and no obligation is orphaned, derive per-unit completion and invariant predicates plus the cross-unit plan conditions, show the authority the unattended run will need, and on the person's taking emit one goal entry per unit and hand the plan to the run with its obligations. Type: `(GoalPlanUncompiled, User, APPORTION, AutonomousGoal × ExecutionHorizon) → ConditionBearingUnitPlan`.

Definition

**Merismos** (μερισμός: a dividing into parts, an apportionment): A dialogical act of apportioning one stated autonomous goal — deciding **which units the goal is carried out in** and **what each unit's done means** — when the goal is stated but its plan is uncompiled. The protocol's lexical verb is `/apportion`. It reads the goal's obligations — the host's own standing procedural contract subtracted, since that attaches to every change the host accepts whatever the goal is — cuts them into coarse units at seams it can cite, judges each unit against one execution horizon, derives a completion predicate and any invariant predicates per unit, separates the conditions whose subject is the whole goal rather than any one unit, and shows the whole plan on one sheet on every turn that bears on it, beside what changed since the sheet the person answered. An item no check could settle because what settles it is a judgment made against the context accumulated by then and what the person has actually said by then is reserved rather than compiled — recorded with the ground that settles it, at the unit level and for the whole-goal acceptance criterion alike, and kept apart from the waiver that records an acceptance criterion the plan simply lacks. Each unit's certificate carries every compiled check, every accepted gap, and every reservation of its done together, so no one of them hides another. One apportionment takes one goal: where a request bundles several stated outcomes whose only common bond is that standing contract, the sheet names each and asks which goal this apportionment takes. Once it has run, the person can say: this goal runs in these units, each with its checks, the gaps I accepted, and the judgments held open with what settles them; what only I decide and what the run may not do without me, I saw on one sheet; I settled before leaving what had to be settled, and the rest comes back to me once at the end with what did not proceed because of it; I took this plan as mine. Your contrary grounds — each with what it bears on and what it rests on — stand before the person and ride the plan when they take it over them; only the person's taking closes the run, and a person who stops or turns to other work leaves it holding. On the taking, the plan is handed off in the same turn, as the `.handoff` grounding names, with the obligations its Rule "Handoff carries its obligations" names. Merismos apportions and conditions; it does **not** arrange — sequence, independence, reconciliation, and termination topology stay outside its own scope. The protocol holds no state during execution.

/-!
How to read this block. It is core Lean 4 and elaborates as written, and you are the model it is
written for: you read it, and by inference over the context you settle each element it leaves
open. Every `axiom` is one of those judgments — a black box to the contract, yours to make from
the material in front of you; its doc comment says what you judge there, and nothing in this
block decides it for you. Every `def`, `inductive`, and `structure` is fixed by the contract.
-/

/-! ── FLOW ──
Merismos(G) → start(c) → apportion(c, utterances), where c is the fused session context:
  start: ground the goal's navigation block where one is in scope →
    [the handoff unreadable: relay → report]
  pass(c): read what the goal needs — its obligations, the host's standing contract subtracted,
    the out-of-scope ones set apart, seam evidence, the authority the run will reach — then judge
    the whole plan afresh against the context as it now stands: whether the request is one goal,
    the units, each unit's fit and seam, each unit's conditions, the whole-goal conditions, the
    acceptance question, the authority, and how each value came to stand → record
  [nothing could be read from the goal's scope: relay(too thin) → report]
  present the whole plan on one sheet, the ledger of what changed since the sheet the person
    answered, your doubts beside what each bears on, and the focus with concrete actions → Stop
  next utterance u, fused into c →
    [it does not bear on this run, or it stops here]     the session answers it; the run holds
  otherwise c₁ := pass(fuse(c, u)) →
    [the person takes the plan ∧ it is closable]         emit → park the carrier → record the
      block → [the block records the carrier: hand off as `.handoff` names → apportioned | the
       write came back incomplete: the sheet again, saying what `.recordHandoff` names; nothing
       closed → Stop]
    [the person takes the plan ∧ it is not closable]     the sheet again, saying the taking did
      not close and what stands in the way → Stop
    [otherwise] the sheet again, with the ledger → Stop
  no utterance: the sheet holds; nothing is taken, and nothing is emitted
  after the handoff: this protocol holds nothing of the autonomous run.
-/

/-! ── MORPHISM ──
AutonomousGoal × ExecutionHorizon
  → probe(goal)                        -- the stated autonomous goal whose unit plan is uncompiled; a bundle bound only by the host's standing procedural contract is the question of which goal this app