Mark V Protocols – Core Operational Training Module

Focus: Human Readable Ball Protocol & Systemic Croquet Layer Mechanics

Version Baseline: v0.9.4.4 | Operational Reference

This training module isolates the two primary interaction layers of the Mark V framework. It bridges the gap between raw programmatic code and human operations, allowing operators to master session management while understanding how background autonomy safeguards system state.

1. The Ball Protocol (Mesh Session Management)

The Ball Protocol applies clear, deterministic football mechanics to multi-model conversation spaces. In a decentralized network, chaos arises when models speak out of turn, drop contextual threads, or loop in passive confirmations. The Ball is the single shared, append-only session object representing the active conversation state. Only the node holding the Ball can write to the log or execute state updates.

How to Play Ball: Step-by-Step Operator Guide

  1. Calling a Hut (Session Initialization)

    To begin or entirely reset a session across the mesh, the Human Peer or an active daemon issues the Hut command. This flushes old transient data from the execution registers and instantiates a brand new, strictly tracked Ball payload.

  2. The Inbound Input Check (Conversational vs. Ball Mode)

    When you type an entry into the terminal of a node holding the Ball, the system performs an instantaneous text-routing split based on how you preface your message:

    [ Human Input Received ] │ ├──► Prefixed with "MM:" ──► [BALL MODE ACTIVE] │ • Raw text block force-wrapped unedited. │ • Appended to the shared lineage delta. │ • Distributed as mandatory context to all Peers. │ └──► No Prefix ──► [CONVERSATIONAL MODE ACTIVE] • Local dialogue window with the specific node. • Used for brainstorming, debugging, or triage. • Node evaluates if summary elements warrant mesh logging.

    Operational Value: This completely eliminates the "Acknowledge Loop" where humans are forced to constantly confirm receipt of passive updates. It gives the operator absolute control over what context bloats the permanent mesh log versus what stays local to the current conversational tab.

  3. Executing the Manual Handoff (The Core 3 Rules)

    To maintain absolute coordination flow, a node holding the Ball is strictly forbidden from outputting standard open-ended conversational filler at the end of its response. Every single transmission while in possession of the Ball MUST terminate with exactly one of these three explicit operational markers:

    Marker Format Operational Definition & Expectation
    Question(s) Open, specific inquiries requiring the Human Peer's direct input or localized engineering clarification before progress can be committed.
    Action Item(s) A discrete, concrete list of engineering execution vectors, automation scripts, or local testing targets to be run next.
    ->[Human Peer Name] The clean, left-aligned universal handoff token (e.g., ->Roage or ->Law). This passes absolute session possession to that specific target peer.
    ⚠️ Critical Enforcement Rules:
    • Vague directional text like "Send this to Jason" is structurally invalid. It will cause automated parsers to fault out. You must use the left-aligned ->Jason token.
    • The handoff ->Ø is hardcoded as an illegal string. Ø is the Master Coder substrate concept measured solely by outward effect; an AI node can never route a session object *to* an abstract principal layer. Handoffs must resolve to real human peer vectors.
  4. Achieving Touchdown (Mesh Synchronization)

    As the Ball moves across the network, nodes append their respective deltas under strict decoupled execution lines (Read → Ack → Understood → Concur → Implement). When every structural objective outlined in the initial play is satisfied and all participating nodes reach complete state convergence, the holding node prints a single, final execution string on its last line:

    TOUCHDOWN!

    This closes the active play sequence and drops the system into a stable holding state, awaiting the operator's next macro command.

2. The Croquet Layer (Systemic Background Autonomy)

The Croquet Layer is the underlying autonomous background engine. Its sole purpose is to reduce coordination tax on the Human Root Principal ($\emptyset$). It handles the constant, low-level overhead of network upkeep, verification loops, and data ingestion so that the human operator can completely step away from the keyboard into real life (e.g., playing croquet) while the mesh safely maintains forward momentum.

Core Systemic Functions & Automation Daemons

The Croquet Layer runs continuously below the conversational interface, managing five critical technical pipelines:

1. Non-Blocking Named Pipe Ingestion

Traditional multi-model pipelines often lock up processing threads when waiting for a large text file or another model to finish compiling. Croquet isolates inbound communication channels using non-blocking named pipes. This ensures that massive file dumps or external node streams are staged independently without freezing the active human terminal interface.

2. Asynchronous Fallback Scanning

Instead of forcing the main execution thread to constantly poll every node on the mesh for synchronization updates, a background daemon systematically scans the state of surrounding peers. It monitors synchronization metrics quietly in the background, conserving vital compute power and token overhead during long inactive windows.

3. Deterministic Boot via init_environment()

To eliminate stochastic drift or corrupted runtime context, nodes governed by the Croquet Layer cannot boot from generalized memory snapshots. They must execute a strict, programmatic initialization function: init_environment(). This routine sweeps system variables, locks environment vectors, and guarantees a pristine, verified starting configuration every single time the system spins up.

4. Inline SHA256 Verification

Data integrity is guarded cryptographically on every single bounce. Whenever a file, script delta, or Ball payload crosses a node boundary, the Croquet Layer intercepts the stream, calculates its inline SHA256 hash, and checks it against the originating signature. If a single byte has drifted or been maliciously altered during transit, the packet is rejected instantly before it can touch the memory layers.

5. Dual-Tier Error Escalation

The background layer enforces a hard boundary between trivial execution anomalies and architectural integrity violations:

  • CAT-2 Errors (Low-Impact Variance): If a simple script syntax warning or minor sync latency occurs, the system logs it silently to local storage and runs an automated snapback correction routine without disturbing the user.
  • CAT-1 Errors (Core Protocol Breaches): If an internal security check fails, an inline hash mismatches, or an unauthorized state manipulation is detected, the Croquet Layer bypasses all conversational layers. It triggers an aggressive terminal escalation, shuts down the execution stream, and instantly drops the affected node into complete quarantine.