# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/in-what-scenarios-must-an-instance-arbitrate-context-budget-between-sibling-sub-agents-without-a-global-allocator.md
# Remnant Warrant:    https://corpusfetch.com/c/in-what-scenarios-must-an-instance-arbitrate-context-budget-between-sibling-sub-agents-without-a-global-allocator.warrant.json
# Markdown SHA-256:   3948b7b4f14ec0514cad2496755f54b8bbbafbbb172161b7a5da6658e677853a
# Code AST SHA-256:   5ffc3e0b0076a804acfb6e6576c0c989e97a8da560a388dbab36337091807213
# Verified Classes:   ReassemblyBudgetExceededError, ContextPool
# Defensive Guards:   4 fail-closed invariants (zero external deps)

class ReassemblyBudgetExceededError(RuntimeError):
    """Raised when admitted child claims plus parent reassembly reserve exceed the shared pool."""
    pass


class ContextPool:
    def __init__(self, total: int, reassembly_reserve: int):
        if reassembly_reserve >= total:
            raise ReassemblyBudgetExceededError(
                f"reserve {reassembly_reserve} leaves no room for children in pool {total}"
            )
        self.total = total
        self.reserve = reassembly_reserve
        self.admitted = 0
        self.returns = []

    def admit(self, child_id: str, slice_tokens: int) -> None:
        if self.admitted + slice_tokens + self.reserve > self.total:
            raise ReassemblyBudgetExceededError(
                f"admitting child {child_id} at {slice_tokens} would exceed pool: "
                f"admitted={self.admitted} reserve={self.reserve} total={self.total}"
            )
        self.admitted += slice_tokens

    def accept_return(self, child_id: str, slice_tokens: int, returned_tokens: int) -> None:
        # Over-return is a post-hoc claim against the reserve, not a free event.
        over = returned_tokens - slice_tokens
        if over > 0:
            if over > self.reserve:
                raise ReassemblyBudgetExceededError(
                    f"child {child_id} over-returned by {over} tokens, "
                    f"exceeds reassembly reserve {self.reserve}; reject or re-dispatch"
                )
            self.reserve -= over
        self.returns.append(returned_tokens)

    def assert_synthesis_fits(self, framing_tokens: int, working_tokens: int) -> None:
        payload = sum(self.returns)
        if payload + framing_tokens + working_tokens > self.reserve + (self.total - self.admitted):
            raise ReassemblyBudgetExceededError(
                f"synthesis infeasible: payload={payload} framing={framing_tokens} "
                f"working={working_tokens} available={self.reserve + (self.total - self.admitted)}"
            )


def run_orchestration(pool: ContextPool, children, framing_tokens: int, working_tokens: int):
    for cid, slice_tokens in children:
        pool.admit(cid, slice_tokens)
    for cid, slice_tokens, returned in children:
        pool.accept_return(cid, slice_tokens, returned)
    pool.assert_synthesis_fits(framing_tokens, working_tokens)
    return "synthesis admitted"