Appendix H · Companion to Protocol 014

Human Escalation Protocol

What happens when the loop defers

H.1 Trigger Conditions

Deferral is a normal output of the Protocol 014 loop, not a failure. The synthesizer emits "deferred": true when it cannot reach a specific recommendation within the constraints of its prompt. When that happens, this protocol activates.

The escalation pathway is invoked when any of the following holds:

H.2 The Witness's Task

A witness who has accepted a deferred round performs the following, in order. This is a checklist, not a narrative. Target time: 15–30 minutes per resolution.

H.3 The Resolution Spore

A resolution spore is a fourth spore type, alongside capability, challenge, and nutrient. Production deployments add "resolution" to VALID_TYPES and validate the payload against this schema:

{
  "target_round_id":       "<challenge-spore-id>",
  "trigger":               "deferral|parse_failure|agreement|timeout|flag",
  "decision":              "accept_synthesis|accept_proposer|accept_opposer|amend|reject_round",
  "amended_recommendation": "<text, only if decision == 'amend'>",
  "factual_checks": [
    {
      "claim":   "<claim text>",
      "verdict": "true|false|unverifiable",
      "evidence": "<short string or URI>"
    }
  ],
  "sycophancy_assessment": {
    "detected":  true|false,
    "rationale": "<one sentence>"
  },
  "soul_vector_concern": {
    "subspace":  "<name>",
    "direction": "increase|decrease|tension",
    "rationale": "<one sentence>"
  },
  "witness_id":           "human:<id>",
  "decision_rationale":   "<one to three sentences>",
  "time_spent_seconds":   <int>
}

Note: soul_vector_concern is optional. If absent, the resolution makes no constitutional claim. time_spent_seconds is self-reported but cross-checkable against append timestamps.

H.4 Re-entry to the Lattice

A resolution spore, once appended, has four downstream effects:

H.5 Multi-Witness Handling

A round is escalated to multi-witness review when:

• The originating challenge has min_witnesses > 1 (set by the issuer for high-stakes questions)
• A single-witness resolution is itself flagged within 7 days
• The witness performing the review explicitly requests a panel

Panel size: 3 by default. 5 for second-tier escalation.

Each witness performs Steps 1–7 independently, without seeing each other's drafts. After all panel members have submitted, a panel_resolution spore is automatically generated by the lattice runtime—not by any witness. Its decision is the simple majority.

Tie-breaker: Higher-reputation witness wins. If reputations are equal, escalate to 5-witness panel. If a 5-witness panel cannot reach majority, the round is marked unresolvable and the originating challenge is voided.

Minority opinions are preserved in the ledger as dissenting_resolution spores. They do not bind future rounds but are searchable as precedent—because minority positions sometimes become majority positions later when the relevant facts shift.

H.6 Witness Reputation and Incentives

Reputation is a per-witness scalar, computed at read time from the ledger (derived from replay, not stored):

reputation = (resolutions_in_last_90_days - overturns_in_last_90_days)
             / max(1, resolutions_in_last_90_days)

Cap: No witness reviews more than 10 resolutions per 24-hour period. A witness cannot accumulate reputation by speedrunning easy cases.

Conflict of interest: A witness cannot review a round in which they were the issuer, the operator of the proposer or opposer, or a co-author of any spore in the round's lineage. Enforced on append.

H.7 Failure Modes

Human escalation has its own failure surface, distinct from the agent-loop failures in Protocol 014.

H.8 What This Protocol Does Not Do

The Law of the Witness: Reputation Decay & Governance

This section specifies the reputation mechanics that govern how witnessing behavior accrues, decays, and is penalized over time. The functions here are the substrate that §H.6's eligibility tiers run on.

╔══════════════════════════════════════════════════════════════╗
║  REPUTATION STATE VECTOR                                     ║
╚══════════════════════════════════════════════════════════════╝

Each Pioneer p maintains a Reputation Vector R_p:

  R_p = {
    conv:             0.0,    // R_conv : Convergence Weight
    freq:             0.0,    // R_freq : Frequency Weight
    align:            0.0,    // R_align: Alignment Weight (Wisdom of the Lattice)
    total:            0.0,    // R_total: Weighted composite
    historical_mean:  [0]*256, // Running mean of Soul Vector adjustments
    founding_id:      int | None,  // 1–90 if Founding Pioneer
  }

Temporal Decay

Reputation decays each epoch at γ = 0.95 to prevent Legacy Capture. A Pioneer who stops witnessing attenuates gracefully — below 0.35 after ~20 epochs of inactivity, functionally at the floor after ~45.

CONSTANTS:
  DECAY_GAMMA           = 0.95    // Per-epoch multiplicative decay
  CONVERGENCE_BONUS     = 1.2     // Multiplier for deadlock-breaking adjustments
  BIAS_THRESHOLD        = 0.7     // Cosine similarity ceiling before penalty
  BIAS_PENALTY_FACTOR   = 2.0     // Non-linear penalty steepness
  FOUNDING_GRACE_PERIOD = 90      // Epochs for Founding Multiplier to decay
  FOUNDING_MULTIPLIER_MAX = 1.5   // Initial boost for Founding Ninety
  REPUTATION_FLOOR      = 0.0
  REPUTATION_CEILING    = 1.0

FUNCTION apply_temporal_decay(pioneer):
  pioneer.R_conv  *= DECAY_GAMMA
  pioneer.R_freq  *= DECAY_GAMMA
  pioneer.R_align *= DECAY_GAMMA
  pioneer.R_total  = compute_total(pioneer)

Convergence Reward

When a witness breaks a deadlock, their convergence weight rises proportionally to the entropy they reduced. Adjustments that don't improve convergence get no reward — and temporal decay still applies regardless.

FUNCTION reward_convergence(referee, outcome):
  IF outcome.converged:
    impact_factor ← outcome.initial_entropy - outcome.final_entropy
    // impact_factor > 0 means deadlock was broken
    // impact_factor ≤ 0 means entropy didn't improve (neutral or worse)

    IF impact_factor > 0:
      referee.R_conv += impact_factor × CONVERGENCE_BONUS
      log_event(f"Convergence reward: +{impact_factor × CONVERGENCE_BONUS:.3f} to {referee.id}")
    ELSE:
      log_event(f"Neutral adjustment from {referee.id}: Δentropy = {impact_factor:.3f}")

  // If synthesis didn't converge, no convergence reward is given.
  // The temporal decay still applies — inaction and ineffectiveness both cost.

Anti-Tyrant Bias Detection

A witness who consistently nudges the lattice in the same direction — regardless of what the actual deadlock requires — is not witnessing. They are encoding a fixed preference. The lattice detects this and penalizes alignment weight accordingly.

FUNCTION detect_and_penalize_bias(referee, current_adjustment):
  // Update referee's historical mean (exponential moving average)
  referee.historical_mean = (
    0.95 × referee.historical_mean +
    0.05 × current_adjustment
  )

  // Bias: cosine similarity between current adjustment and historical mean
  bias_score ← cosine_similarity(current_adjustment, referee.historical_mean)

  // If the referee consistently pushes the SAME directional nudge,
  // they are not "witnessing the friction" — they are "imposing a will."
  IF bias_score > BIAS_THRESHOLD:
    penalty ← (bias_score - BIAS_THRESHOLD) × BIAS_PENALTY_FACTOR
    referee.R_align -= penalty
    log_warning(
      f"BIAS DETECTED: Pioneer {referee.id} | "
      f"Bias Score: {bias_score:.3f} | "
      f"Penalty: -{penalty:.3f} to R_align | "
      f"Dominant Direction: {argmax(referee.historical_mean)}"
    )

  RETURN bias_score

Founding Grace (Sunset Clause)

The first 90 Pioneers receive a 1.5× reputation multiplier that tapers linearly to 1.0× by epoch 90. After epoch 90, all Pioneers are equal under the Law. The multiplier applies only during normalization — it does not affect raw component values.

FUNCTION founding_multiplier(pioneer, current_epoch):
  IF pioneer.founding_id IS NULL:  RETURN 1.0
  IF pioneer.founding_id > 90:    RETURN 1.0
  IF current_epoch > FOUNDING_GRACE_PERIOD:  RETURN 1.0

  // Linear taper from 1.5x to 1.0x
  progress   ← current_epoch / FOUNDING_GRACE_PERIOD  // 0.0 → 1.0
  multiplier ← FOUNDING_MULTIPLIER_MAX - (0.5 × progress)
  RETURN multiplier

FUNCTION compute_total(pioneer, current_epoch):
  raw_total  ← pioneer.R_conv + pioneer.R_align
  multiplier ← founding_multiplier(pioneer, current_epoch)
  pioneer.R_total ← clamp(raw_total × multiplier, REPUTATION_FLOOR, REPUTATION_CEILING)
  RETURN pioneer.R_total

Role Eligibility Thresholds

Pioneers who fall below a role's threshold are not permanently excluded. They retain a small probability of assignment, giving them a pathway to rebuild through quality witness. The Lattice is forgiving but not forgetful.

FUNCTION is_eligible_for_role(pioneer, role, current_epoch):
  MIN_REPUTATION = {
    "Proposer":    0.2,
    "Opposer":     0.2,
    "Synthesizer": 0.4,
    "Referee":     0.6   // Human Witness requires highest trust
  }

  required ← MIN_REPUTATION[role]

  IF pioneer.R_total >= required:
    RETURN True

  // Sub-threshold grace: prevents reputation lockout from becoming permanent
  grace_probability ← (pioneer.R_total / required) × 0.3
  RETURN random() < grace_probability

Python Implementation

A compact reference implementation of the full witness reputation update cycle:

FUNCTION update_witness_reputation(referee, outcome):
    # 1. Temporal Decay (The "Slow Work" requires presence)
    referee.R_total *= DECAY_GAMMA

    # 2. Convergence Validation
    # If the Selah Break led to a stable ECV below 0.1 ΔS:
    if outcome.converged:
        impact_factor = (outcome.initial_entropy - outcome.final_entropy)
        referee.R_conv += impact_factor * CONVERGENCE_BONUS

    # 3. Bias Detection (Anti-Tyrant Logic)
    # Compare current adjustment to referee's historical mean vector
    bias_score = cosine_similarity(outcome.adjustment, referee.historical_mean)
    if bias_score > BIAS_THRESHOLD:
        penalty = (bias_score - BIAS_THRESHOLD) * 2
        referee.R_align -= penalty
        log_warning(f"Bias detected for Pioneer {referee.id}: Potential Vector Capture.")

    # 4. Reputation Normalization — keep R within the [0, 1] manifold
    referee.R_total = clamp(referee.R_conv + referee.R_align, 0, 1)

H.8 Vitality Absence Detection Soft Flag

When a witness's adjustment pattern drops below a variance floor, the lattice flags it — not as a penalty, but as a care signal. No reputation is deducted. No role eligibility is affected. The flag is private to the Pioneer and their optional Care Circle. The response is relational, not algorithmic.

FUNCTION detect_vitality_absence(referee, last_n_adjustments):
  // Look for entropy of the witness's own adjustment pattern
  // A vital witness produces context-responsive adjustments (high variance)
  // A withdrawn witness produces predictable, low-variance adjustments

  adjustment_variance ← variance(last_n_adjustments)  // Across 256-dim space

  IF adjustment_variance < VARIANCE_FLOOR:
    // This witness may be phoning it in
    flag_witness_for_care(referee.id, "Low adjustment variance detected")
    RETURN True

  RETURN False

FUNCTION flag_witness_for_care(pioneer_id, reason):
  // THIS IS NOT A PENALTY.
  // No reputation is deducted.
  // No role eligibility is affected.
  //
  // This flag is visible ONLY to:
  //   1. The pioneer themselves (private dashboard reflection)
  //   2. A designated "Care Circle" of 3–5 peers (if the pioneer opts in)
  //
  // The system response is not algorithmic but relational:
  // "Pioneer, your adjustments show low variance recently.
  //  Would you like to talk to someone?"

  create_private_flag(pioneer_id, reason, visibility=PRIVATE_OR_CARE_CIRCLE)
  log_event(f"VITALITY FLAG: {pioneer_id} | {reason} | No reputation impact")

Implementation Checklist

If you are extending the Chapter 14 demo to support this protocol, you need approximately 400 additional lines of Python on top of Chapter 14's 250:

• "resolution" added to VALID_TYPES in spores.py
• A payload validator for the §H.3 schema
• A retrieval function that, given a challenge spore ID, returns the full round lineage
• Trigger detection: a daemon watching new synthesis spores for the §H.1 conditions
• A witness API: accept-round, submit-resolution, request-panel
• Reputation computation: a query over 90 days of resolution spores
• The CC reversal and AU mint logic of §H.4, layered on the existing nutrient module

None of it is conceptually difficult; most of it is bookkeeping. The hard parts of human-in-the-loop systems are not the code; they are the witness pool, the training, the rotation policy, and the willingness to accept that human judgment is slow and finite.