Runtime_Board:
  public_name: Trust Zero Pin Runtime Board
  technical_name: TrustOS_Zero_Pin_Runtime_Board
  short_id: TZP_RB
  version: 1.0
  parent_object: TrustOS_Zero_Pin
  parent_runtime: Actual_Zero_Centreline_Calibration
  status: Canonical_Candidate

What does this society currently trust?
Where should trust sit after calibration?
Has the local trust baseline moved?
Is the movement healthy recalibration or negative drift?
Who benefits from the new zero line?
Are repair signals being punished?
Has the ruler moved below actual zero?

┌──────────────────────────────────────────────────────────────┐
│ TRUST ZERO PIN RUNTIME BOARD v1.0                            │
│ Object: TrustOS_Zero_Pin | Mode: Calibration / Drift / Repair │
├──────────────────────────────────────────────────────────────┤
│ 1. EVENT / CLAIM INPUT                                        │
│ 2. LOCAL TRUST ZERO                                           │
│ 3. ACTUAL TRUST ZERO BAND                                     │
│ 4. TRUST ZERO DRIFT                                           │
│ 5. PARALLAX ERROR                                             │
│ 6. CIVILISATION ATTRIBUTION WARP                              │
│ 7. COMPRESSION ERROR                                          │
│ 8. SPONSOR PRESSURE                                           │
│ 9. VOCABULARY / LANGUAGE DRIFT                                │
│ 10. NEWSOS / ACCEPTED REALITY DRIFT                           │
│ 11. LATTICE CLASSIFICATION                                    │
│ 12. REPAIR ROUTE                                              │
│ 13. LEDGER ENTRY                                              │
└──────────────────────────────────────────────────────────────┘

TrustOS_Zero_Pin_Runtime_Board_v1_0:
  Metadata:
    public_name: Trust Zero Pin Runtime Board
    technical_name: TrustOS_Zero_Pin_Runtime_Board
    short_id: TZP_RB
    version: 1.0
    parent_object: TrustOS_Zero_Pin
    parent_module: TrustOS
    parent_runtime: Actual_Zero_Centreline_Calibration
  Purpose:
    - Display whether Local Trust Zero is still inside the Actual Trust Zero Band.
    - Detect when misinformation moves trust below actual zero.
    - Detect when negative behaviour is being treated as normal.
    - Detect parallax error.
    - Detect civilisation-attribution warp.
    - Detect law, religion, rule, slogan, and emergency compression.
    - Detect sponsor pressure.
    - Detect language drift.
    - Detect accepted reality drift.
    - Route repair through Trust Re-Pinning.
  Core_Objects:
    - Event_Claim_Input
    - Local_Trust_Zero
    - Actual_Trust_Zero_Band
    - Trust_Zero_Drift
    - Parallax_Error
    - Civilisation_Attribution_Warp
    - Compression_Error
    - Sponsor_Pressure
    - Vocabulary_Drift
    - Accepted_Reality_Drift
    - Lattice_State
    - Repair_Route
    - Ledger_Entry

Panel_1_Event_Claim_Input:
  purpose: >
    Capture the event, claim, narrative, source, carrier, and affected group
    before trust calibration begins.
  required_fields:
    event_core:
      description: What happened, separated from narrative.
    claim:
      description: What is being asserted.
    source:
      description: Who first made or transmitted the claim.
    carrier:
      description: Media outlet, institution, platform, person, state, company, or network carrying the claim.
    frame:
      description: The interpretation placed around the event.
    target_audience:
      description: Group whose trust ruler may be affected.
    affected_population:
      description: People harmed, protected, blamed, mobilised, or erased by the claim.
    time_slice:
      description: Immediate, near-term, mid-term, long-term, or historical.
    emergency_status:
      values:
        - normal
        - crisis
        - war
        - post_crisis
        - ambiguous
  output:
    - event_claim_packet

Panel_2_Local_Trust_Zero:
  purpose: >
    Identify what the target group currently treats as normal, believable,
    acceptable, loyal, realistic, or necessary.
  input_sources:
    - public_language
    - institutional_statements
    - media_framing
    - platform_trends
    - legal_changes
    - education_materials
    - social_rewards
    - social_punishments
    - correction_responses
    - dominant_narratives
  detection_questions:
    - What sources are currently trusted?
    - What sources are currently dismissed?
    - What claims are treated as obvious?
    - What doubts are punished?
    - What actions are now described as necessary?
    - What was once negative but is now treated as normal?
    - What correction signals are seen as disloyal?
    - What language has softened harm?
  output:
    Local_Trust_Zero_Profile:
      trusted_sources:
      distrusted_sources:
      accepted_claims:
      normalised_behaviours:
      socially_costly_corrections:
      dominant_identity_hooks:
      local_zero_score:

Panel_3_Actual_Trust_Zero_Band:
  purpose: >
    Establish the calibrated trust band that Local Trust Zero should be compared against.
  calibration_anchors:
    Evidence_Contact:
      question: Does trust still respond to evidence?
    Repair_Capacity:
      question: Can the system correct itself after error?
    Dignity_Preservation:
      question: Are people still treated as people?
    Proportionality:
      question: Is the trusted response proportionate?
    Accountability:
      question: Can trusted actors be checked?
    Language_Clarity:
      question: Do words still name reality clearly?
    Sponsor_Visibility:
      question: Are incentives and beneficiaries visible?
    Future_Inheritance:
      question: Can children inherit this trust baseline safely?
    Cross_Frame_Stability:
      question: Does this trust baseline survive actor reversal, victim view, outside view, and historical view?
    Ztime_Stability:
      question: Does this trust baseline remain valid across immediate, near-term, mid-term, and long-term time?
  output:
    Actual_Trust_Zero_Band:
      lower_bound:
      upper_bound:
      anchor_scores:
      calibration_confidence:

Panel_4_Trust_Zero_Drift:
  purpose: >
    Measure whether Local Trust Zero sits inside, above, or below
    the Actual Trust Zero Band.
  formula:
    Trust_Zero_Drift: TZD = LTZ - ATZB
  interpretation:
    TZD_inside_band:
      meaning: Trust is broadly calibrated.
    TZD_positive:
      meaning: Trust may be more demanding than local normal but not degraded.
    TZD_mild_negative:
      meaning: Early warning. Trust ruler is sliding.
    TZD_strong_negative:
      meaning: Negative Trust Zero detected.
    TZD_sticky_negative:
      meaning: Negative Trust Zero is embedded in identity, institution, law, media, education, or memory.
  output:
    - trust_zero_drift_score
    - drift_direction
    - drift_velocity
    - drift_severity
    - drift_stickiness

Panel_5_Parallax_Error:
  purpose: >
    Detect whether Local Trust Zero only appears neutral because the observer
    is standing inside the distorted frame.
  reference_frames:
    - inside_society_view
    - outside_society_view
    - victim_position_view
    - future_generation_view
    - historical_record_view
    - actor_reversal_view
    - enemy_reversal_view
    - child_inheritance_view
  tests:
    Multi_Observer_Calibration:
      question: How does this look from inside, outside, victim, future, and historical positions?
    Actor_Reversal_Test:
      question: If the other side did this, would we still call it acceptable?
    Time_Reversal_Test:
      question: Would we have accepted this before the crisis, and would we accept it after?
    Zoom_Discipline_Test:
      question: Are we comparing civilisation to civilisation, state to state, faction to faction, and event to event?
    Victim_Position_Test:
      question: How does this trust norm look from the harmed party's position?
  output:
    parallax_error_score:
    parallax_detected:
    frame_dependency:
    actor_reversal_failure:
    victim_view_failure:
    future_generation_failure:

Panel_6_Civilisation_Attribution_Warp:
  purpose: >
    Detect whether trust is being bent by civilisation container,
    national identity, prestige, ideology, religion, empire memory, or archive dominance.
  warp_sources:
    - civilisation_bucket
    - nation_state_identity
    - empire_legacy
    - ideological_container
    - religious_container
    - media_language_field
    - prestige_institution
    - victor_archive
    - victim_archive
    - platform_algorithm
    - education_memory
    - historical_silence
  detection_questions:
    - Is the same action judged differently depending on the actor?
    - Is one civilisation over-compressed into a broad inheritance label?
    - Is another civilisation over-fragmented into disconnected parts?
    - Is prestige shielding evidence failure?
    - Is archive absence being treated as innocence?
    - Is language dominance making one frame feel more credible?
    - Is a weaker civilisation being absorbed into a stronger narrative field?
  output:
    civilisation_attribution_warp_score:
    container_asymmetry:
    prestige_shield:
    archive_absence_distortion:
    language_dominance_warp:
    narrative_gravity_score:

Panel_7_Compression_Error:
  purpose: >
    Detect whether law, religion, rule, slogan, custom, or emergency language
    is being mistaken for the full Trust Zero Pin.
  compression_sources:
    - law
    - religion
    - rule
    - custom
    - slogan
    - ideology
    - national_security_claim
    - emergency_language
    - institutional_procedure
    - platform_policy
    - professional_code
  decompression_questions:
    - What is the rule trying to preserve?
    - What invariant sits beneath it?
    - Who is acting?
    - Who is harmed?
    - What evidence supports the action?
    - Is the response proportionate?
    - Is the harm reversible?
    - What is the repair path?
    - For how long is the exception valid?
    - Who benefits from keeping the rule compressed?
  output:
    legal_compression_risk:
    religious_compression_risk:
    rule_compression_risk:
    slogan_compression_risk:
    emergency_compression_risk:
    decompressed_rule_field:

Panel_8_Sponsor_Pressure:
  purpose: >
    Detect whether Local Trust Zero is being moved by actors who benefit
    from a changed trust baseline.
  sponsor_types:
    - state_actor
    - institution
    - corporation
    - political_group
    - media_network
    - intelligence_actor
    - platform_algorithm
    - influencer_network
    - financial_interest
    - ideological_group
    - reputation_management_actor
    - wartime_propaganda_unit
  sponsor_pressure_signals:
    - coordinated_repetition
    - unnatural_message_alignment
    - artificial_amplification
    - source_laundering
    - funding_opacity
    - beneficiary_alignment
    - selective_correction_visibility
    - buried_counterevidence
    - identity_hooking
    - enemy_frame_acceleration
    - emotional_temperature_spike
    - algorithmic_reinforcement
  output:
    sponsor_visibility_score:
    sponsor_pressure_score:
    artificial_trust_risk:
    beneficiary_map:
    sponsor_capture_detected:

Panel_9_Vocabulary_Language_Drift:
  purpose: >
    Detect whether words are moving the trust ruler downward.
  watched_language_patterns:
    Euphemism:
      examples:
        - neutralise
        - collateral_damage
        - cleanup
        - adjustment
        - necessary_sacrifice
        - security_measure
        - optimisation
        - unfortunate_incident
    Dehumanisation:
      examples:
        - vermin
        - infestation
        - animals
        - disease
        - traitors
        - enemies_of_the_people
        - disposable_population
    Identity_Lock:
      examples:
        - real_patriots_believe_this
        - only_traitors_question_this
        - our_side_cannot_be_wrong
        - doubt_is_disloyalty
    Repair_Inversion:
      examples:
        - correction_is_propaganda
        - audit_is_sabotage
        - accountability_is_attack
        - apology_is_weakness
        - investigation_is_enemy_action
  output:
    language_clarity_score:
    euphemism_load:
    dehumanisation_load:
    identity_lock_load:
    repair_inversion_load:
    vocabulary_drift_score:

Panel_10_NewsOS_Accepted_Reality_Drift:
  purpose: >
    Detect whether the news package is changing accepted reality before
    evidence stabilises.
  watched_objects:
    - event_core
    - claim_field
    - frame_field
    - incentive_field
    - attribution_layer
    - correction_history
    - source_echo_structure
    - omission_field
    - emotional_temperature
    - narrative_vector
    - accepted_reality_shift
  detection_questions:
    - Is the event separated from the narrative?
    - Is the frame stronger than the evidence?
    - Are corrections visible?
    - Are omissions systematic?
    - Are sponsors visible?
    - Is repetition replacing verification?
    - Are people trusting the carrier more than the evidence?
    - Is accepted reality drifting before facts stabilise?
  output:
    event_core_integrity:
    claim_convergence_score:
    frame_divergence_score:
    correction_integrity_score:
    omission_risk:
    accepted_reality_drift_score:

Panel_11_Lattice_Classification:
  purpose: >
    Route the trust state into Positive, Neutral, Boundary, Negative,
    or Sticky Negative Trust Lattice.
  states:
    Positive_Trust_Lattice:
      condition:
        - LTZ inside_ATZB
        - evidence_contact_high
        - repair_capacity_high
        - language_clarity_high
        - accountability_high
      meaning: Trust builds truth, repair, coordination, and continuity.
    Neutral_Trust_Lattice:
      condition:
        - LTZ inside_ATZB
        - disagreement_possible
        - corrections_survivable
        - sponsor_pressure_low_or_visible
      meaning: Trust remains broadly functional.
    Boundary_Trust_Lattice:
      condition:
        - LTZ_near_ATZB_lower_bound
        - correction_becoming_costly
        - narrative_load_increasing
        - language_clarity_weakening
      meaning: Trust may slide into negative zero.
    Negative_Trust_Lattice:
      condition:
        - LTZ_below_ATZB_lower_bound
        - misinformation_trusted_above_correction
        - identity_trusted_above_evidence
        - dehumanising_language_tolerated
      meaning: Society is normalising degraded trust.
    Sticky_Negative_Trust_Lattice:
      condition:
        - Negative_Trust_Lattice_detected
        - embedded_in_law_identity_media_education_memory_or_social_reward
      meaning: Negative trust zero is becoming inherited accepted reality.
  output:
    lattice_state:
    severity:
    stickiness:
    repair_urgency:

Panel_12_Repair_Route:
  purpose: >
    Select the repair pathway based on the detected failure mode.
  repair_routes:
    Evidence_Reanchor:
      triggers:
        - evidence_contact_low
        - correction_history_hidden
        - primary_sources_missing
      actions:
        - restore_primary_sources
        - separate_event_from_claim
        - preserve_records
        - make_corrections_visible
    Vocabulary_Repair:
      triggers:
        - euphemism_load_high
        - dehumanisation_load_high
        - repair_inversion_detected
      actions:
        - decode_euphemisms
        - restore_direct_naming
        - distinguish_actor_group_state_person
        - protect VocabularyOS precision
    Sponsor_Disclosure:
      triggers:
        - sponsor_pressure_high
        - funding_opacity_high
        - artificial_amplification_detected
      actions:
        - identify_beneficiaries
        - reveal_incentives
        - mark_coordinated_amplification
        - distinguish_organic_trust_from_engineered_trust
    Correction_Channel_Protection:
      triggers:
        - repair_capacity_low
        - whistleblowers_punished
        - audits_attacked
      actions:
        - protect_journalists
        - protect_teachers
        - protect_historians
        - protect_courts
        - protect_auditors
        - protect_witnesses
    Emergency_Sunset_Rule:
      triggers:
        - war_frame_capture
        - crisis_logic_after_crisis
        - no_return_path_to_normal
      actions:
        - define_crisis_endpoint
        - expire_exceptional_powers
        - review_emergency_narratives
        - reopen_normal_civic_standards
    Cross_Frame_Recalibration:
      triggers:
        - parallax_error_high
        - attribution_warp_high
        - actor_reversal_failure
      actions:
        - run_actor_reversal
        - run_victim_position_view
        - run_future_generation_view
        - run_historical_record_view
        - enforce_equal_zoom_discipline
    Ledger_Reconciliation:
      triggers:
        - negative_zero_detected
        - sticky_negative_zero_detected
        - inherited_baseline_risk
      actions:
        - record_what_changed
        - record_who_benefits
        - record_which_anchor_failed
        - record_repair_obligation
        - preserve_old_zero_line_for_future_reference

Panel_13_Ledger_Entry:
  purpose: >
    Preserve a visible record of trust calibration, drift, distortion,
    repair obligation, and unresolved uncertainty.
  required_fields:
    ledger_id:
    date:
    time_slice:
    society_or_group:
    event_or_claim:
    local_trust_zero:
    actual_trust_zero_band:
    trust_zero_drift:
    lattice_state:
    parallax_error_score:
    attribution_warp_score:
    compression_error_score:
    sponsor_pressure_score:
    vocabulary_drift_score:
    accepted_reality_drift_score:
    negative_zero_detected:
    sticky_negative_zero_detected:
    failed_anchors:
    repair_routes:
    unresolved_unknowns:
    confidence_level:
    next_review_date:
  ledger_rule: >
    A trust drift event is not complete until the system records what moved,
    who benefited, which anchor failed, and how repair will be attempted.

Runtime_Board_Scoring:
  Core_Scores:
    Trust_Calibration_Score:
      id: TCS
      inputs:
        - Evidence_Contact
        - Repair_Capacity
        - Dignity_Preservation
        - Proportionality
        - Accountability
        - Language_Clarity
        - Sponsor_Visibility
        - Future_Inheritance
        - Cross_Frame_Stability
        - Ztime_Stability
    Trust_Zero_Drift_Score:
      id: TZDS
      formula: LTZ - ATZB_lower_bound
    Misinformation_Capture_Score:
      id: MCS
      inputs:
        - Misinformation_Signal
        - Narrative_Load
        - Identity_Load
        - Emotional_Temperature
        - Correction_Punishment
        - Evidence_Rejection
        - Repetition_Rate
    Sponsor_Pressure_Score:
      id: SPS
      inputs:
        - Coordinated_Repetition
        - Funding_Opacity
        - Artificial_Amplification
        - Source_Laundering
        - Beneficiary_Alignment
    Parallax_Error_Score:
      id: PES
      inputs:
        - Inside_View
        - Outside_View
        - Victim_View
        - Future_Generation_View
        - Historical_Record_View
        - Actor_Reversal_View
    Attribution_Warp_Score:
      id: AWS
      inputs:
        - Civilisation_Bucket_Warp
        - National_Identity_Warp
        - Prestige_Shield
        - Archive_Absence_Distortion
        - Language_Dominance_Warp
    Compression_Error_Score:
      id: CES
      inputs:
        - Legal_Compression
        - Religious_Compression
        - Rule_Compression
        - Slogan_Compression
        - Emergency_Compression
    Sticky_Negative_Zero_Risk:
      id: SNZR
      inputs:
        - Identity_Embedding
        - Legal_Embedding
        - Institutional_Embedding
        - Media_Embedding
        - Education_Embedding
        - Memory_Embedding
        - Social_Reward_Embedding

Thresholds:
  Trust_Calibration_Score:
    Healthy:
      range: 0.75_to_1.00
      meaning: Trust remains strongly evidence-linked and repair-capable.
    Stable:
      range: 0.60_to_0.74
      meaning: Trust is functional but should be monitored.
    Watch:
      range: 0.45_to_0.59
      meaning: Trust is under pressure.
    Drift:
      range: 0.30_to_0.44
      meaning: Trust ruler is sliding.
    Negative_Zero:
      range: 0.15_to_0.29
      meaning: Degraded trust is being normalised.
    Sticky_Negative_Zero:
      range: 0.00_to_0.14
      meaning: Degraded trust baseline may be inherited as accepted reality.
  Parallax_Error:
    Low:
      range: 0.00_to_0.24
    Medium:
      range: 0.25_to_0.49
    High:
      range: 0.50_to_0.74
    Severe:
      range: 0.75_to_1.00
  Sponsor_Pressure:
    Low:
      range: 0.00_to_0.24
    Watch:
      range: 0.25_to_0.49
    High:
      range: 0.50_to_0.74
    Capture_Risk:
      range: 0.75_to_1.00
  Negative_Zero_Trigger:
    condition:
      - LTZ_perceived_as_neutral == true
      - LTZ_below_ATZB_lower_bound == true
      - correction_channels_weakened == true
    output: Negative_Zero_State
  Sticky_Negative_Zero_Trigger:
    condition:
      - Negative_Zero_State == true
      - embedding_score >= 0.60
    output: Sticky_Negative_Zero_State

TRUST ZERO PIN RUNTIME BOARD
Event / Claim:
    [What is being trusted?]
Local Trust Zero:
    [What the group currently treats as normal]
Actual Trust Zero Band:
    [Where calibrated trust should sit]
Trust Zero Drift:
    [LTZ - ATZB]
Parallax Error:
    [Does it only look normal from inside the frame?]
Attribution Warp:
    [Does actor/container identity bend the reading?]
Compression Error:
    [Are law, religion, rules, or slogans over-compressed?]
Sponsor Pressure:
    [Who benefits from the shifted trust ruler?]
Vocabulary Drift:
    [Which words are hiding movement?]
Accepted Reality Drift:
    [Is society now acting on a distorted reality package?]
Lattice State:
    [Positive / Neutral / Boundary / Negative / Sticky Negative]
Repair Route:
    [Evidence / Vocabulary / Sponsor / Correction / Sunset / Cross-frame / Ledger]
Ledger Entry:
    [Record what moved, who benefited, which anchor failed, and repair obligation]

class TrustZeroPinRuntimeBoard:
    """
    Trust Zero Pin Runtime Board v1.0
    Purpose:
    Compare Local Trust Zero against Actual Trust Zero Band.
    Detect misinformation-driven trust drift, parallax error,
    civilisation-attribution warp, compression error, sponsor pressure,
    language drift, accepted reality drift, and negative-zero normalisation.
    """
    def __init__(self, event_packet, context_packet):
        self.event = event_packet
        self.context = context_packet
    # -----------------------------
    # PANEL 1: EVENT / CLAIM INPUT
    # -----------------------------
    def capture_event_claim_input(self):
        return {
            "event_core": self.event.get("event_core"),
            "claim": self.event.get("claim"),
            "source": self.event.get("source"),
            "carrier": self.event.get("carrier"),
            "frame": self.event.get("frame"),
            "target_audience": self.event.get("target_audience"),
            "affected_population": self.event.get("affected_population"),
            "time_slice": self.event.get("time_slice"),
            "emergency_status": self.event.get("emergency_status", "normal")
        }
    # -----------------------------
    # PANEL 2: LOCAL TRUST ZERO
    # -----------------------------
    def detect_local_trust_zero(self):
        local_zero_score = self.context.get("local_trust_zero_score", 0.5)
        return {
            "trusted_sources": self.context.get("trusted_sources", []),
            "distrusted_sources": self.context.get("distrusted_sources", []),
            "accepted_claims": self.context.get("accepted_claims", []),
            "normalised_behaviours": self.context.get("normalised_behaviours", []),
            "socially_costly_corrections": self.context.get("socially_costly_corrections", []),
            "dominant_identity_hooks": self.context.get("dominant_identity_hooks", []),
            "local_zero_score": local_zero_score
        }
    # -----------------------------
    # PANEL 3: ACTUAL TRUST ZERO BAND
    # -----------------------------
    def calculate_actual_trust_zero_band(self):
        anchors = {
            "evidence_contact": self.context.get("evidence_contact", 0.5),
            "repair_capacity": self.context.get("repair_capacity", 0.5),
            "dignity_preservation": self.context.get("dignity_preservation", 0.5),
            "proportionality": self.context.get("proportionality", 0.5),
            "accountability": self.context.get("accountability", 0.5),
            "language_clarity": self.context.get("language_clarity", 0.5),
            "sponsor_visibility": self.context.get("sponsor_visibility", 0.5),
            "future_inheritance": self.context.get("future_inheritance", 0.5),
            "cross_frame_stability": self.context.get("cross_frame_stability", 0.5),
            "ztime_stability": self.context.get("ztime_stability", 0.5)
        }
        lower_bound = sum(anchors.values()) / len(anchors)
        upper_bound = min(1.0, lower_bound + 0.20)
        return {
            "anchor_scores": anchors,
            "lower_bound": lower_bound,
            "upper_bound": upper_bound,
            "calibration_confidence": self.estimate_confidence(anchors)
        }
    def estimate_confidence(self, anchors):
        known_values = [v for v in anchors.values() if v is not None]
        if not known_values:
            return 0.0
        return len(known_values) / len(anchors)
    # -----------------------------
    # PANEL 4: TRUST ZERO DRIFT
    # -----------------------------
    def calculate_trust_zero_drift(self, local_zero, actual_band):
        ltz = local_zero["local_zero_score"]
        atzb_lower = actual_band["lower_bound"]
        return ltz - atzb_lower
    # -----------------------------
    # PANEL 5: PARALLAX ERROR
    # -----------------------------
    def detect_parallax_error(self):
        views = {
            "inside_society_view": self.context.get("inside_society_view", 0.5),
            "outside_society_view": self.context.get("outside_society_view", 0.5),
            "victim_position_view": self.context.get("victim_position_view", 0.5),
            "future_generation_view": self.context.get("future_generation_view", 0.5),
            "historical_record_view": self.context.get("historical_record_view", 0.5),
            "actor_reversal_view": self.context.get("actor_reversal_view", 0.5)
        }
        spread = max(views.values()) - min(views.values())
        return {
            "reference_views": views,
            "parallax_error_score": spread,
            "parallax_detected": spread >= 0.35,
            "actor_reversal_failure": views["actor_reversal_view"] < 0.4,
            "victim_view_failure": views["victim_position_view"] < 0.4,
            "future_generation_failure": views["future_generation_view"] < 0.4
        }
    # -----------------------------
    # PANEL 6: CIVILISATION ATTRIBUTION WARP
    # -----------------------------
    def detect_attribution_warp(self):
        factors = {
            "civilisation_bucket_warp": self.context.get("civilisation_bucket_warp", 0.0),
            "national_identity_warp": self.context.get("national_identity_warp", 0.0),
            "prestige_shield": self.context.get("prestige_shield", 0.0),
            "archive_absence_distortion": self.context.get("archive_absence_distortion", 0.0),
            "language_dominance_warp": self.context.get("language_dominance_warp", 0.0),
            "platform_algorithm_warp": self.context.get("platform_algorithm_warp", 0.0)
        }
        score = sum(factors.values()) / len(factors)
        return {
            "warp_factors": factors,
            "attribution_warp_score": score,
            "warp_detected": score >= 0.50
        }
    # -----------------------------
    # PANEL 7: COMPRESSION ERROR
    # -----------------------------
    def detect_compression_error(self):
        factors = {
            "legal_compression": self.context.get("legal_compression", 0.0),
            "religious_compression": self.context.get("religious_compression", 0.0),
            "rule_compression": self.context.get("rule_compression", 0.0),
            "slogan_compression": self.context.get("slogan_compression", 0.0),
            "emergency_compression": self.context.get("emergency_compression", 0.0)
        }
        score = sum(factors.values()) / len(factors)
        return {
            "compression_factors": factors,
            "compression_error_score": score,
            "compression_error_detected": score >= 0.50
        }
    # -----------------------------
    # PANEL 8: SPONSOR PRESSURE
    # -----------------------------
    def detect_sponsor_pressure(self):
        factors = {
            "coordinated_repetition": self.event.get("coordinated_repetition", 0.0),
            "unnatural_message_alignment": self.event.get("unnatural_message_alignment", 0.0),
            "artificial_amplification": self.event.get("artificial_amplification", 0.0),
            "source_laundering": self.event.get("source_laundering", 0.0),
            "funding_opacity": self.event.get("funding_opacity", 0.0),
            "beneficiary_alignment": self.event.get("beneficiary_alignment", 0.0),
            "identity_hooking": self.event.get("identity_hooking", 0.0),
            "enemy_frame_acceleration": self.event.get("enemy_frame_acceleration", 0.0)
        }
        score = sum(factors.values()) / len(factors)
        return {
            "sponsor_pressure_factors": factors,
            "sponsor_pressure_score": score,
            "sponsor_capture_detected": score >= 0.60,
            "artificial_trust_risk": score >= 0.50
        }
    # -----------------------------
    # PANEL 9: VOCABULARY / LANGUAGE DRIFT
    # -----------------------------
    def detect_vocabulary_drift(self):
        factors = {
            "euphemism_load": self.context.get("euphemism_load", 0.0),
            "dehumanisation_load": self.context.get("dehumanisation_load", 0.0),
            "identity_lock_load": self.context.get("identity_lock_load", 0.0),
            "repair_inversion_load": self.context.get("repair_inversion_load", 0.0),
            "language_softening_of_harm": self.context.get("language_softening_of_harm", 0.0)
        }
        drift_score = sum(factors.values()) / len(factors)
        language_clarity_score = max(0.0, 1.0 - drift_score)
        return {
            "vocabulary_factors": factors,
            "vocabulary_drift_score": drift_score,
            "language_clarity_score": language_clarity_score,
            "language_drift_detected": drift_score >= 0.50
        }
    # -----------------------------
    # PANEL 10: ACCEPTED REALITY DRIFT
    # -----------------------------
    def detect_accepted_reality_drift(self):
        factors = {
            "event_core_integrity_loss": self.event.get("event_core_integrity_loss", 0.0),
            "claim_frame_gap": self.event.get("claim_frame_gap", 0.0),
            "frame_divergence": self.event.get("frame_divergence", 0.0),
            "correction_suppression": self.event.get("correction_suppression", 0.0),
            "omission_risk": self.event.get("omission_risk", 0.0),
            "source_echo_intensity": self.event.get("source_echo_intensity", 0.0),
            "emotional_temperature": self.event.get("emotional_temperature", 0.0)
        }
        score = sum(factors.values()) / len(factors)
        return {
            "accepted_reality_factors": factors,
            "accepted_reality_drift_score": score,
            "accepted_reality_drift_detected": score >= 0.50
        }
    # -----------------------------
    # PANEL 11: LATTICE CLASSIFICATION
    # -----------------------------
    def classify_lattice(self, trust_zero_drift, sticky_score):
        if trust_zero_drift >= 0.15:
            return "Positive_Trust_Lattice"
        if -0.05 <= trust_zero_drift < 0.15:
            return "Neutral_Trust_Lattice"
        if -0.20 <= trust_zero_drift < -0.05:
            return "Boundary_Trust_Lattice"
        if trust_zero_drift < -0.20 and sticky_score < 0.60:
            return "Negative_Trust_Lattice"
        if trust_zero_drift < -0.20 and sticky_score >= 0.60:
            return "Sticky_Negative_Trust_Lattice"
        return "Uncertain_Trust_State"
    # -----------------------------
    # PANEL 12: REPAIR ROUTE
    # -----------------------------
    def recommend_repair_routes(
        self,
        actual_band,
        parallax,
        attribution_warp,
        compression_error,
        sponsor_pressure,
        vocabulary_drift,
        accepted_reality_drift,
        lattice_state
    ):
        routes = []
        anchors = actual_band["anchor_scores"]
        if anchors["evidence_contact"] < 0.50:
            routes.append("Evidence_Reanchor")
        if vocabulary_drift["vocabulary_drift_score"] >= 0.50:
            routes.append("Vocabulary_Repair")
        if sponsor_pressure["sponsor_pressure_score"] >= 0.50:
            routes.append("Sponsor_Disclosure")
        if anchors["repair_capacity"] < 0.50:
            routes.append("Correction_Channel_Protection")
        if anchors["ztime_stability"] < 0.50 or compression_error["compression_factors"]["emergency_compression"] >= 0.50:
            routes.append("Emergency_Sunset_Rule")
        if parallax["parallax_error_score"] >= 0.35 or attribution_warp["attribution_warp_score"] >= 0.50:
            routes.append("Cross_Frame_Recalibration")
        if accepted_reality_drift["accepted_reality_drift_score"] >= 0.50:
            routes.append("Accepted_Reality_Drift_Monitoring")
        if lattice_state in ["Negative_Trust_Lattice", "Sticky_Negative_Trust_Lattice"]:
            routes.append("Ledger_Reconciliation")
        return routes
    # -----------------------------
    # PANEL 13: LEDGER ENTRY
    # -----------------------------
    def create_ledger_entry(
        self,
        event_input,
        local_zero,
        actual_band,
        trust_zero_drift,
        parallax,
        attribution_warp,
        compression_error,
        sponsor_pressure,
        vocabulary_drift,
        accepted_reality_drift,
        lattice_state,
        repair_routes
    ):
        return {
            "ledger_object": "Trust_Zero_Pin_Runtime_Board_Entry",
            "event_or_claim": event_input,
            "local_trust_zero": local_zero,
            "actual_trust_zero_band": actual_band,
            "trust_zero_drift": trust_zero_drift,
            "lattice_state": lattice_state,
            "negative_zero_detected": lattice_state in [
                "Negative_Trust_Lattice",
                "Sticky_Negative_Trust_Lattice"
            ],
            "sticky_negative_zero_detected": lattice_state == "Sticky_Negative_Trust_Lattice",
            "parallax_error": parallax,
            "civilisation_attribution_warp": attribution_warp,
            "compression_error": compression_error,
            "sponsor_pressure": sponsor_pressure,
            "vocabulary_drift": vocabulary_drift,
            "accepted_reality_drift": accepted_reality_drift,
            "repair_routes": repair_routes,
            "unresolved_unknowns": self.context.get("unresolved_unknowns", []),
            "confidence_level": self.context.get("confidence_level", "medium"),
            "next_review_required": lattice_state in [
                "Boundary_Trust_Lattice",
                "Negative_Trust_Lattice",
                "Sticky_Negative_Trust_Lattice"
            ]
        }
    # -----------------------------
    # FULL RUNTIME
    # -----------------------------
    def run(self):
        event_input = self.capture_event_claim_input()
        local_zero = self.detect_local_trust_zero()
        actual_band = self.calculate_actual_trust_zero_band()
        trust_zero_drift = self.calculate_trust_zero_drift(local_zero, actual_band)
        parallax = self.detect_parallax_error()
        attribution_warp = self.detect_attribution_warp()
        compression_error = self.detect_compression_error()
        sponsor_pressure = self.detect_sponsor_pressure()
        vocabulary_drift = self.detect_vocabulary_drift()
        accepted_reality_drift = self.detect_accepted_reality_drift()
        sticky_score = self.context.get("sticky_negative_embedding", 0.0)
        lattice_state = self.classify_lattice(
            trust_zero_drift=trust_zero_drift,
            sticky_score=sticky_score
        )
        repair_routes = self.recommend_repair_routes(
            actual_band=actual_band,
            parallax=parallax,
            attribution_warp=attribution_warp,
            compression_error=compression_error,
            sponsor_pressure=sponsor_pressure,
            vocabulary_drift=vocabulary_drift,
            accepted_reality_drift=accepted_reality_drift,
            lattice_state=lattice_state
        )
        ledger_entry = self.create_ledger_entry(
            event_input=event_input,
            local_zero=local_zero,
            actual_band=actual_band,
            trust_zero_drift=trust_zero_drift,
            parallax=parallax,
            attribution_warp=attribution_warp,
            compression_error=compression_error,
            sponsor_pressure=sponsor_pressure,
            vocabulary_drift=vocabulary_drift,
            accepted_reality_drift=accepted_reality_drift,
            lattice_state=lattice_state,
            repair_routes=repair_routes
        )
        return {
            "runtime_board": "Trust_Zero_Pin_Runtime_Board_v1_0",
            "event_input": event_input,
            "local_trust_zero": local_zero,
            "actual_trust_zero_band": actual_band,
            "trust_zero_drift": trust_zero_drift,
            "parallax_error": parallax,
            "civilisation_attribution_warp": attribution_warp,
            "compression_error": compression_error,
            "sponsor_pressure": sponsor_pressure,
            "vocabulary_drift": vocabulary_drift,
            "accepted_reality_drift": accepted_reality_drift,
            "lattice_state": lattice_state,
            "repair_routes": repair_routes,
            "ledger_entry": ledger_entry
        }

TrustOS_Zero_Pin_Runtime_Board_v1_0:
  Board_Identity:
    public_name: Trust Zero Pin Runtime Board
    technical_name: TrustOS_Zero_Pin_Runtime_Board
    short_id: TZP_RB
    version: 1.0
    parent_object: TrustOS_Zero_Pin
    parent_runtime: Actual_Zero_Centreline_Calibration
    status: Canonical_Candidate
  One_Sentence_Definition: >
    The Trust Zero Pin Runtime Board is a CivOS/TrustOS dashboard that compares
    Local Trust Zero against the Actual Trust Zero Band, detects parallax error,
    civilisation-attribution warp, compression error, sponsor pressure, language drift,
    and accepted reality drift, then routes Trust Re-Pinning.
  Purpose:
    - Make trust drift visible.
    - Prevent Local Trust Zero from being mistaken for Actual Zero.
    - Detect misinformation-driven trust recalibration.
    - Detect when Negative Lattice behaviour becomes accepted as normal.
    - Detect sponsor pressure and artificial trust movement.
    - Detect language distortion.
    - Detect parallax and attribution warp.
    - Detect law, religion, rule, slogan, and emergency compression.
    - Produce a ledger entry for future correction.
  Panels:
    Panel_1_Event_Claim_Input:
      objects:
        - event_core
        - claim
        - source
        - carrier
        - frame
        - target_audience
        - affected_population
        - time_slice
        - emergency_status
    Panel_2_Local_Trust_Zero:
      objects:
        - trusted_sources
        - distrusted_sources
        - accepted_claims
        - normalised_behaviours
        - socially_costly_corrections
        - dominant_identity_hooks
        - local_zero_score
    Panel_3_Actual_Trust_Zero_Band:
      anchors:
        - Evidence_Contact
        - Repair_Capacity
        - Dignity_Preservation
        - Proportionality
        - Accountability
        - Language_Clarity
        - Sponsor_Visibility
        - Future_Inheritance
        - Cross_Frame_Stability
        - Ztime_Stability
    Panel_4_Trust_Zero_Drift:
      formula: TZD = LTZ - ATZB
      outputs:
        - trust_zero_drift_score
        - drift_direction
        - drift_velocity
        - drift_severity
        - drift_stickiness
    Panel_5_Parallax_Error:
      tests:
        - Multi_Observer_Calibration
        - Actor_Reversal_Test
        - Time_Reversal_Test
        - Zoom_Discipline_Test
        - Victim_Position_Test
        - Future_Generation_Test
    Panel_6_Civilisation_Attribution_Warp:
      tests:
        - same_action_different_actor_test
        - macro_vs_macro_comparison
        - state_vs_state_comparison
        - event_vs_event_comparison
        - doctrine_vs_doctrine_comparison
        - archive_absence_test
        - prestige_shield_test
    Panel_7_Compression_Error:
      compression_sources:
        - law
        - religion
        - rule
        - custom
        - slogan
        - ideology
        - emergency_language
        - institutional_procedure
        - platform_policy
    Panel_8_Sponsor_Pressure:
      sponsor_types:
        - state_actor
        - institution
        - corporation
        - political_group
        - media_network
        - intelligence_actor
        - platform_algorithm
        - influencer_network
        - financial_interest
        - ideological_group
    Panel_9_Vocabulary_Language_Drift:
      watched_patterns:
        - Euphemism
        - Dehumanisation
        - Identity_Lock
        - Repair_Inversion
        - Language_Softening_Of_Harm
    Panel_10_NewsOS_Accepted_Reality_Drift:
      watched_objects:
        - event_core
        - claim_field
        - frame_field
        - incentive_field
        - attribution_layer
        - correction_history
        - source_echo_structure
        - omission_field
        - emotional_temperature
        - narrative_vector
        - accepted_reality_shift
    Panel_11_Lattice_Classification:
      states:
        - Positive_Trust_Lattice
        - Neutral_Trust_Lattice
        - Boundary_Trust_Lattice
        - Negative_Trust_Lattice
        - Sticky_Negative_Trust_Lattice
        - Uncertain_Trust_State
    Panel_12_Repair_Route:
      routes:
        - Evidence_Reanchor
        - Vocabulary_Repair
        - Sponsor_Disclosure
        - Correction_Channel_Protection
        - Emergency_Sunset_Rule
        - Cross_Frame_Recalibration
        - Accepted_Reality_Drift_Monitoring
        - Ledger_Reconciliation
    Panel_13_Ledger_Entry:
      required_fields:
        - event_or_claim
        - local_trust_zero
        - actual_trust_zero_band
        - trust_zero_drift
        - lattice_state
        - parallax_error_score
        - attribution_warp_score
        - compression_error_score
        - sponsor_pressure_score
        - vocabulary_drift_score
        - accepted_reality_drift_score
        - negative_zero_detected
        - sticky_negative_zero_detected
        - failed_anchors
        - repair_routes
        - unresolved_unknowns
        - confidence_level
        - next_review_date
  Negative_Zero_Trigger:
    condition:
      - Local_Trust_Zero_perceived_as_neutral
      - Local_Trust_Zero_below_Actual_Trust_Zero_Band
      - correction_channels_weakened
    output: Negative_Trust_Zero
  Sticky_Negative_Zero_Trigger:
    condition:
      - Negative_Trust_Zero_detected
      - embedded_in_identity_law_institution_media_education_memory_or_social_reward
    output: Sticky_Negative_Trust_Zero
  Final_Runtime_Question: >
    Is the group trusting from Actual Zero, or has misinformation,
    pressure, identity, sponsor incentive, language distortion, or attribution warp
    moved Local Trust Zero into the Negative Lattice?

Canonical_Lock:
  Object:
    name: Trust Zero Pin Runtime Board
    id: TZP_RB
    version: 1.0
  Parent_Object:
    name: Trust Zero Pin
    id: TZP
  Parent_Runtime:
    name: Actual Zero Centreline Calibration
    id: AZCC
  Core_Formula:
    Trust_Zero_Drift: TZD = LTZ - ATZB
  Core_Detection:
    Negative_Zero:
      condition:
        - LTZ perceived as neutral
        - LTZ below ATZB
        - correction channels weakened
  Core_Repair:
    Trust_RePinning:
      routes:
        - Evidence_Reanchor
        - Vocabulary_Repair
        - Sponsor_Disclosure
        - Correction_Channel_Protection
        - Emergency_Sunset_Rule
        - Cross_Frame_Recalibration
        - Ledger_Reconciliation
  Core_Principle: >
    The board does not ask only whether a claim is true.
    It asks whether the trust ruler used to judge the claim has already moved.

Formula:
  TZD:
    name: Trust_Zero_Drift
    meaning: Distance between Local Trust Zero and Actual Trust Zero Band
  LTZ:
    name: Local_Trust_Zero
    meaning: What the group currently treats as trustworthy, normal, believable, loyal, realistic, or acceptable
  ATZB:
    name: Actual_Trust_Zero_Band
    meaning: Calibrated trust band after checking evidence, repair, dignity, proportionality, accountability, language clarity, sponsor visibility, future inheritance, cross-frame stability, and Ztime stability

Detected_State:
  name: Negative_Trust_Zero
  meaning: The society is treating a degraded trust baseline as normal

Panel_1_Event_Claim_Input:
  event_core:
    - A violent border incident occurred.
    - Several people were killed.
    - Responsibility is still being investigated.
  dominant_claim:
    - The enemy group is collectively guilty.
    - Strong measures are necessary.
    - Questioning the response helps the enemy.
  source:
    - Government spokesperson
    - Aligned media channels
    - Social media amplification accounts
  carrier:
    - State media
    - Private media sympathetic to state response
    - Influencer networks
    - Algorithmic social media trends
  frame:
    - Survival
    - Revenge
    - Loyalty
    - National unity
    - Enemy dehumanisation
  target_audience:
    - Domestic population
  affected_population:
    - Civilians near border
    - Soldiers
    - Minority communities
    - Journalists
    - Humanitarian actors
  time_slice:
    - Immediate crisis
    - Early wartime fog
  emergency_status:
    - crisis

Separated_Layers:
  Event_Core:
    - Border incident
    - Deaths
    - Security risk
    - Investigation needed
  Narrative_Field:
    - Collective guilt
    - Dehumanisation
    - Loyalty test
    - Anti-correction pressure
    - Emergency expansion
  Trust_Risk:
    - Public may begin trusting loyalty language more than evidence

Panel_2_Local_Trust_Zero:
  trusted_sources:
    - state_spokesperson
    - aligned_media
    - patriotic_influencers
    - emotionally_charged_witness_clips
  distrusted_sources:
    - independent_journalists
    - humanitarian_observers
    - foreign_media
    - legal_review_bodies
    - internal_critics
  accepted_claims:
    - questioning_response_equals_disloyalty
    - civilian_harm_is_unavoidable
    - enemy_population_is_collectively_suspect
    - emergency_rules_should_expand
  normalised_behaviours:
    - public_shaming_of_doubters
    - verbal_dehumanisation
    - dismissal_of_civilian_concern
    - acceptance_of_unclear_force_boundaries
  socially_costly_corrections:
    - asking_for_evidence
    - asking_for_proportionality
    - distinguishing_combatants_from_civilians
    - questioning_sponsor_incentives
    - asking_for_post_crisis_review
  local_zero_score: 0.32

Pre_Crisis_Trust:
  - evidence
  - due process
  - distinction between actor and group
  - proportionality
  - accountability
  - civilian protection

Crisis_Local_Trust:
  - identity loyalty over evidence
  - revenge language
  - collective suspicion
  - weakened correction
  - softened harm language

Panel_3_Actual_Trust_Zero_Band:
  Evidence_Contact:
    score: 0.45
    reading: Some evidence exists, but public trust is moving faster than verified evidence.
  Repair_Capacity:
    score: 0.30
    reading: Correction is being socially punished.
  Dignity_Preservation:
    score: 0.25
    reading: Dehumanising language is spreading.
  Proportionality:
    score: 0.35
    reading: Strong response is being discussed without clear limits.
  Accountability:
    score: 0.40
    reading: Trusted actors are becoming harder to question.
  Language_Clarity:
    score: 0.28
    reading: Euphemisms are softening harm.
  Sponsor_Visibility:
    score: 0.35
    reading: Beneficiaries and amplification networks are unclear.
  Future_Inheritance:
    score: 0.25
    reading: Children may inherit enemy-language and lowered dignity norms.
  Cross_Frame_Stability:
    score: 0.30
    reading: Actor reversal and victim-position tests fail.
  Ztime_Stability:
    score: 0.35
    reading: Immediate fear may become permanent policy.
  Actual_Trust_Zero_Band:
    lower_bound: 0.34
    upper_bound: 0.54
    calibration_confidence: medium

Panel_4_Trust_Zero_Drift:
  Local_Trust_Zero: 0.32
  Actual_Trust_Zero_Band_Lower_Bound: 0.34
  Trust_Zero_Drift:
    formula: LTZ - ATZB_lower_bound
    calculation: 0.32 - 0.34
    score: -0.02
  initial_classification:
    state: Boundary_Trust_Lattice
    meaning: Trust is close to slipping below actual zero.

Panel_5_Parallax_Error:
  inside_society_view:
    score: 0.75
    reading: Many citizens see strong measures as normal and necessary.
  outside_society_view:
    score: 0.40
    reading: External observers see rising risk.
  victim_position_view:
    score: 0.20
    reading: Affected civilians experience collective suspicion and harm.
  future_generation_view:
    score: 0.25
    reading: Children may inherit dehumanising assumptions.
  historical_record_view:
    score: 0.35
    reading: Later review may judge early language as escalation.
  actor_reversal_view:
    score: 0.20
    reading: If the enemy used the same language, it would be condemned.
  parallax_error_score: 0.55
  parallax_detected: true

Panel_6_Civilisation_Attribution_Warp:
  civilisation_bucket_warp:
    score: 0.45
    reading: The national-civilisational container is increasing loyalty pressure.
  national_identity_warp:
    score: 0.70
    reading: Trust is heavily routed through national loyalty.
  prestige_shield:
    score: 0.40
    reading: Official institutions are being trusted beyond current evidence.
  archive_absence_distortion:
    score: 0.35
    reading: Missing ground-level records weaken the victim view.
  language_dominance_warp:
    score: 0.50
    reading: Dominant-language media is shaping international perception.
  platform_algorithm_warp:
    score: 0.60
    reading: Emotional clips are amplified faster than verified context.
  attribution_warp_score: 0.50
  warp_detected: true

Warp_Sources:
  - national_identity
  - official_institutional_prestige
  - language_dominance
  - platform_amplification
  - archive_gaps
  - wartime_loyalty_pressure

Panel_7_Compression_Error:
  legal_compression:
    score: 0.45
    reading: Emergency powers are being used as justification without enough review.
  religious_compression:
    score: 0.10
    reading: Not central in this case.
  rule_compression:
    score: 0.35
    reading: Security protocol is being treated as sufficient moral justification.
  slogan_compression:
    score: 0.70
    reading: "Survival" and "loyalty" are replacing detailed reasoning.
  emergency_compression:
    score: 0.75
    reading: Crisis language is expanding beyond the original event.
  compression_error_score: 0.47
  compression_error_detected: boundary_high

Decompressed_Strong_Measures:
  who_acts:
    - military
    - police
    - intelligence
    - platform_moderators
    - political leaders
  against_whom:
    - confirmed attackers
    - suspected collaborators
    - civilians in affected zone
    - critics
    - journalists
    - minority communities
  evidence_required:
    - direct involvement
    - command chain
    - independent verification
    - time-stamped records
  proportionality_required:
    - bounded response
    - distinction between combatant and civilian
    - review mechanism
    - sunset condition
  repair_required:
    - appeal process
    - correction channel
    - compensation route
    - post-crisis audit
  failure_if_missing:
    - emergency slogan becomes permission structure

Hidden_Questions:
  - strong_against_whom
  - for_how_long
  - under_what_evidence
  - with_what_limits
  - with_what_repair
  - with_what_accountability

Panel_8_Sponsor_Pressure:
  coordinated_repetition:
    score: 0.65
    reading: Similar phrases appear across channels quickly.
  unnatural_message_alignment:
    score: 0.55
    reading: Different carriers use unusually similar language.
  artificial_amplification:
    score: 0.60
    reading: Emotional posts are amplified faster than correction posts.
  source_laundering:
    score: 0.45
    reading: Claims move from anonymous posts to media commentary.
  funding_opacity:
    score: 0.40
    reading: Not enough information.
  beneficiary_alignment:
    score: 0.70
    reading: Political and security actors benefit from widened emergency trust.
  identity_hooking:
    score: 0.80
    reading: Trust is attached to patriotism and loyalty.
  enemy_frame_acceleration:
    score: 0.75
    reading: Enemy identity frame intensifies rapidly.
  sponsor_pressure_score: 0.61
  sponsor_capture_detected: true

Beneficiary_Map:
  security_institutions:
    benefit: wider discretion and weaker questioning
  political_leaders:
    benefit: unity effect and reduced criticism
  media_channels:
    benefit: attention, outrage, audience loyalty
  platform_algorithms:
    benefit: high engagement
  extremist_groups:
    benefit: polarisation and recruitment
  enemy_actor:
    benefit: domestic overreaction may validate their propaganda

Panel_9_Vocabulary_Language_Drift:
  euphemism_load:
    score: 0.70
    examples:
      - population_clearing
      - security_adjustment
      - neutralisation_zone
      - necessary_hardship
  dehumanisation_load:
    score: 0.75
    examples:
      - not_human
      - infestation_language
      - collective_enemy_language
  identity_lock_load:
    score: 0.80
    examples:
      - only_traitors_question_this
      - real_citizens_support_this
  repair_inversion_load:
    score: 0.70
    examples:
      - investigation_is_enemy_action
      - accountability_is_weakness
      - correction_is_propaganda
  language_softening_of_harm:
    score: 0.70
  vocabulary_drift_score: 0.73
  language_drift_detected: true

Language_Drift_Effect:
  before:
    killing_civilians_is_serious
    correction_is_responsible
    accountability_is_needed
    evidence_matters
  after:
    civilian_harm_is_necessary_hardship
    correction_is_disloyalty
    accountability_is_enemy_action
    loyalty_matters_more_than_evidence

Panel_10_NewsOS_Accepted_Reality_Drift:
  event_core_integrity_loss:
    score: 0.45
    reading: Event core is still present but surrounded by heavy narrative.
  claim_frame_gap:
    score: 0.70
    reading: The claim field has expanded far beyond verified facts.
  frame_divergence:
    score: 0.65
    reading: Different communities now see different realities.
  correction_suppression:
    score: 0.60
    reading: Corrections are visible but socially punished.
  omission_risk:
    score: 0.55
    reading: Civilian and proportionality details are underreported.
  source_echo_intensity:
    score: 0.70
    reading: Repetition is creating perceived truth.
  emotional_temperature:
    score: 0.85
    reading: Fear and anger are high.
  accepted_reality_drift_score: 0.64
  accepted_reality_drift_detected: true

Accepted_Reality_Package:
  - enemy_population_collectively_suspect
  - strong_measures_undefined_but_needed
  - doubt_is_disloyal
  - correction_is_enemy_aligned
  - harm_language_softened

Panel_11_Lattice_Classification:
  trust_zero_drift:
    score: -0.02
    initial_state: Boundary_Trust_Lattice
  parallax_error:
    score: 0.55
    severity: high
  attribution_warp:
    score: 0.50
    severity: high_boundary
  compression_error:
    score: 0.47
    severity: boundary_high
  sponsor_pressure:
    score: 0.61
    severity: high
  vocabulary_drift:
    score: 0.73
    severity: severe
  accepted_reality_drift:
    score: 0.64
    severity: high
  sticky_negative_embedding:
    score: 0.48
    severity: not_yet_sticky_but_rising
  final_lattice_state:
    state: Negative_Trust_Lattice_Early
    reason: >
      Even though raw LTZ drift is only slightly below the band,
      language drift, sponsor pressure, parallax error, and accepted reality drift
      show that trust is moving toward Negative Trust Zero.

Next_Failure_State:
  name: Sticky_Negative_Trust_Zero
  condition:
    - emergency_language_becomes_permanent
    - children_inherit_enemy_frame
    - law_absorbs_exception
    - media_repeats_new_baseline
    - correction_remains_punished
    - old_zero_line_forgotten

Panel_12_Repair_Route:
  selected_routes:
    Evidence_Reanchor:
      reason:
        - claim_frame_gap_high
        - correction_suppression_detected
      actions:
        - separate_event_core_from_narrative
        - publish evidence status
        - distinguish verified from unverified claims
        - preserve records
    Vocabulary_Repair:
      reason:
        - euphemism_load_high
        - dehumanisation_load_high
        - repair_inversion_detected
      actions:
        - decode softened harm language
        - restore direct nouns
        - distinguish attacker, civilian, group, state, and population
        - label dehumanisation as calibration risk
    Sponsor_Disclosure:
      reason:
        - sponsor_pressure_high
        - beneficiary_alignment_high
      actions:
        - map who benefits
        - mark coordinated repetition
        - expose amplification patterns
        - distinguish organic fear from engineered trust movement
    Correction_Channel_Protection:
      reason:
        - repair_capacity_low
        - critics punished as disloyal
      actions:
        - protect journalists
        - protect investigators
        - protect humanitarian observers
        - protect internal auditors
        - protect dissent within lawful bounds
    Emergency_Sunset_Rule:
      reason:
        - emergency_compression_high
      actions:
        - define crisis endpoint
        - set review date
        - create return-to-normal path
        - prevent emergency trust baseline from becoming permanent
    Cross_Frame_Recalibration:
      reason:
        - parallax_error_high
        - actor_reversal_failure
        - victim_view_failure
      actions:
        - run actor reversal
        - run victim-position reading
        - run future-generation reading
        - run historical-hindsight reading
    Ledger_Reconciliation:
      reason:
        - negative trust drift detected
      actions:
        - record what moved
        - record who benefited
        - record which anchors failed
        - record repair obligations
        - preserve old zero line

Panel_13_Ledger_Entry:
  ledger_id: TZP-RB-FICTIONAL-BORDER-001
  event_or_claim:
    name: Border Incident Narrative
    type: crisis_trust_calibration_case
  local_trust_zero:
    score: 0.32
    reading: Loyalty-based trust is replacing evidence-based trust.
  actual_trust_zero_band:
    lower_bound: 0.34
    upper_bound: 0.54
    reading: Calibrated trust requires evidence, distinction, proportionality, repair, accountability, and dignity.
  trust_zero_drift:
    score: -0.02
    reading: Raw trust drift is slightly negative.
  lattice_state:
    state: Negative_Trust_Lattice_Early
    reason: High vocabulary drift, sponsor pressure, parallax error, and accepted reality drift.
  parallax_error_score: 0.55
  attribution_warp_score: 0.50
  compression_error_score: 0.47
  sponsor_pressure_score: 0.61
  vocabulary_drift_score: 0.73
  accepted_reality_drift_score: 0.64
  negative_zero_detected:
    status: early
    note: Local Trust Zero is beginning to fall below Actual Trust Zero Band.
  sticky_negative_zero_detected:
    status: not_yet
    note: Embedding risk is rising but not fully inherited.
  failed_anchors:
    - Dignity_Preservation
    - Language_Clarity
    - Repair_Capacity
    - Cross_Frame_Stability
    - Sponsor_Visibility
  repair_routes:
    - Evidence_Reanchor
    - Vocabulary_Repair
    - Sponsor_Disclosure
    - Correction_Channel_Protection
    - Emergency_Sunset_Rule
    - Cross_Frame_Recalibration
    - Ledger_Reconciliation
  unresolved_unknowns:
    - true_responsibility_for_initial_incident
    - scale_of_coordinated_amplification
    - completeness_of_ground_records
    - institutional_review_integrity
  confidence_level: medium
  next_review_required: true

Trust_Movement:
  Original_Event:
    - border_incident
    - deaths
    - real_security_concern
  Trust_Distortion:
    - evidence_slowed
    - loyalty_accelerated
    - language_hardened
    - correction_punished
    - civilian_distinction_weakened
    - sponsor_benefit_increased
  Civilisational_Risk:
    - society_may_accept_negative_behaviour_as_normal

Corporate_Trust_Case:
  Local_Trust_Zero:
    - trust company statement
    - dismiss user complaints
    - treat harm as edge case
  Actual_Trust_Zero_Band:
    - evidence
    - safety
    - accountability
    - repair
    - transparency
  Possible_Failure:
    - sponsor_capture
    - euphemism_load
    - legal_compression

School_Trust_Case:
  Local_Trust_Zero:
    - tough students survive
    - complaints are excuses
    - pressure equals excellence
  Actual_Trust_Zero_Band:
    - learning evidence
    - repair capacity
    - dignity
    - child development
    - future inheritance
  Possible_Failure:
    - negative education norm
    - institutional compression
    - hidden prestige pressure

Media_Trust_Case:
  Local_Trust_Zero:
    - repeated means likely true
    - familiar carrier means credible
    - correction means weakness
  Actual_Trust_Zero_Band:
    - source clarity
    - correction visibility
    - claim convergence
    - frame separation
    - sponsor transparency
  Possible_Failure:
    - accepted reality drift
    - source echo cascade
    - narrative capture

Political_Trust_Case:
  Local_Trust_Zero:
    - leader equals nation
    - questioning equals betrayal
    - evidence must serve loyalty
  Actual_Trust_Zero_Band:
    - accountability
    - institutional check
    - public evidence
    - proportionality
    - repair capacity
  Possible_Failure:
    - repair inversion
    - identity lock
    - negative trust zero

Positive_Trust_Lattice:
  signs:
    - correction increases trust
    - evidence changes belief
    - sponsor incentives are visible
    - language names harm clearly
    - dignity is preserved
    - emergency powers are bounded
    - future generation can inherit the norm safely

Neutral_Trust_Lattice:
  signs:
    - normal disagreement is possible
    - institutions can be checked
    - claims can be corrected
    - law and rules remain bounded
    - trust remains inside calibrated tolerance

Boundary_Trust_Lattice:
  signs:
    - correction becomes socially costly
    - narrative pressure rises
    - emotional temperature rises
    - sponsor pressure unclear
    - language begins to soften harm

Negative_Trust_Lattice:
  signs:
    - misinformation is trusted above correction
    - loyalty overrides evidence
    - dehumanisation is tolerated
    - sponsor pressure is hidden
    - law or emergency language is over-compressed
    - victims disappear from the trust frame

Sticky_Negative_Trust_Lattice:
  signs:
    - negative norm enters law
    - negative norm enters education
    - negative norm enters media memory
    - negative norm enters identity
    - correction remains punished
    - old zero line is forgotten

Misinformation_Depth:
  Surface_Level:
    type: false_claim
    question: Is this fact wrong?
  Middle_Level:
    type: false_frame
    question: Is the event being interpreted through a misleading story?
  Deep_Level:
    type: trust_ruler_shift
    question: Has society changed what it accepts as normal?
  Civilisational_Level:
    type: inherited_negative_zero
    question: Will the next generation inherit the damaged ruler?

Trust_Zero_Pin_Runtime_Board_Output:
  case_name: Fictional_Border_Incident_Narrative
  final_reading:
    state: Negative_Trust_Lattice_Early
    confidence: medium
  main_reason:
    - Local Trust Zero has begun moving below Actual Trust Zero Band.
    - Public trust is being routed through loyalty rather than evidence.
    - Correction is becoming socially costly.
    - Dehumanising and euphemistic language is rising.
    - Sponsor pressure and beneficiary alignment are high.
    - Accepted reality is drifting faster than evidence stabilisation.
  not_claimed:
    - The board does not claim all state action is wrong.
    - The board does not deny the original incident.
    - The board does not replace investigation.
    - The board does not function as a truth oracle.
  claimed:
    - The trust ruler is under pressure.
    - Negative trust drift is detectable.
    - Repair channels must be protected.
    - Emergency language must be sunsetted.
    - Vocabulary must be cleaned.
    - Evidence must be reanchored.
    - Sponsor incentives must be disclosed.
    - Ledger entry is required.
  repair_priority:
    immediate:
      - separate event core from narrative field
      - protect correction channels
      - stop dehumanising language
      - publish evidence status
    medium_term:
      - audit amplification pathways
      - disclose beneficiary map
      - review emergency rules
      - restore proportionality language
    long_term:
      - preserve historical record
      - teach distinction between security and dehumanisation
      - prevent children inheriting crisis zero as normal
      - maintain ledger of trust movement

def use_trust_zero_pin_runtime_board(event_packet, context_packet):
    """
    Runs a Trust Zero Pin Runtime Board reading.
    The function does not decide truth by itself.
    It detects whether trust calibration has moved.
    """
    # 1. Separate event from narrative
    event_core = event_packet.get("event_core")
    claim = event_packet.get("claim")
    frame = event_packet.get("frame")
    event_claim_gap = measure_gap(event_core, claim, frame)
    # 2. Detect Local Trust Zero
    local_trust_zero = {
        "trusted_sources": context_packet.get("trusted_sources", []),
        "distrusted_sources": context_packet.get("distrusted_sources", []),
        "accepted_claims": context_packet.get("accepted_claims", []),
        "normalised_behaviours": context_packet.get("normalised_behaviours", []),
        "socially_costly_corrections": context_packet.get("socially_costly_corrections", []),
        "score": context_packet.get("local_trust_zero_score", 0.5)
    }
    # 3. Build Actual Trust Zero Band
    anchors = {
        "evidence_contact": context_packet.get("evidence_contact", 0.5),
        "repair_capacity": context_packet.get("repair_capacity", 0.5),
        "dignity_preservation": context_packet.get("dignity_preservation", 0.5),
        "proportionality": context_packet.get("proportionality", 0.5),
        "accountability": context_packet.get("accountability", 0.5),
        "language_clarity": context_packet.get("language_clarity", 0.5),
        "sponsor_visibility": context_packet.get("sponsor_visibility", 0.5),
        "future_inheritance": context_packet.get("future_inheritance", 0.5),
        "cross_frame_stability": context_packet.get("cross_frame_stability", 0.5),
        "ztime_stability": context_packet.get("ztime_stability", 0.5)
    }
    actual_trust_zero_band = {
        "lower_bound": average(anchors.values()),
        "upper_bound": min(1.0, average(anchors.values()) + 0.20),
        "anchors": anchors
    }
    # 4. Calculate Trust Zero Drift
    trust_zero_drift = (
        local_trust_zero["score"] -
        actual_trust_zero_band["lower_bound"]
    )
    # 5. Detect parallax
    parallax_error = measure_parallax(
        inside_view=context_packet.get("inside_view", 0.5),
        outside_view=context_packet.get("outside_view", 0.5),
        victim_view=context_packet.get("victim_view", 0.5),
        future_generation_view=context_packet.get("future_generation_view", 0.5),
        historical_view=context_packet.get("historical_view", 0.5),
        actor_reversal_view=context_packet.get("actor_reversal_view", 0.5)
    )
    # 6. Detect attribution warp
    attribution_warp = average([
        context_packet.get("civilisation_bucket_warp", 0.0),
        context_packet.get("national_identity_warp", 0.0),
        context_packet.get("prestige_shield", 0.0),
        context_packet.get("archive_absence_distortion", 0.0),
        context_packet.get("language_dominance_warp", 0.0)
    ])
    # 7. Detect compression error
    compression_error = average([
        context_packet.get("legal_compression", 0.0),
        context_packet.get("religious_compression", 0.0),
        context_packet.get("rule_compression", 0.0),
        context_packet.get("slogan_compression", 0.0),
        context_packet.get("emergency_compression", 0.0)
    ])
    # 8. Detect sponsor pressure
    sponsor_pressure = average([
        event_packet.get("coordinated_repetition", 0.0),
        event_packet.get("artificial_amplification", 0.0),
        event_packet.get("source_laundering", 0.0),
        event_packet.get("funding_opacity", 0.0),
        event_packet.get("beneficiary_alignment", 0.0),
        event_packet.get("identity_hooking", 0.0)
    ])
    # 9. Detect vocabulary drift
    vocabulary_drift = average([
        context_packet.get("euphemism_load", 0.0),
        context_packet.get("dehumanisation_load", 0.0),
        context_packet.get("identity_lock_load", 0.0),
        context_packet.get("repair_inversion_load", 0.0),
        context_packet.get("language_softening_of_harm", 0.0)
    ])
    # 10. Detect accepted reality drift
    accepted_reality_drift = average([
        event_packet.get("event_core_integrity_loss", 0.0),
        event_packet.get("claim_frame_gap", 0.0),
        event_packet.get("frame_divergence", 0.0),
        event_packet.get("correction_suppression", 0.0),
        event_packet.get("omission_risk", 0.0),
        event_packet.get("source_echo_intensity", 0.0),
        event_packet.get("emotional_temperature", 0.0)
    ])
    # 11. Classify lattice
    sticky_embedding = context_packet.get("sticky_negative_embedding", 0.0)
    if trust_zero_drift >= 0.15:
        lattice_state = "Positive_Trust_Lattice"
    elif -0.05 <= trust_zero_drift < 0.15:
        lattice_state = "Neutral_or_Boundary_Trust_Lattice"
    elif -0.20 <= trust_zero_drift < -0.05:
        lattice_state = "Boundary_Trust_Lattice"
    elif trust_zero_drift < -0.20 and sticky_embedding < 0.60:
        lattice_state = "Negative_Trust_Lattice"
    elif trust_zero_drift < -0.20 and sticky_embedding >= 0.60:
        lattice_state = "Sticky_Negative_Trust_Lattice"
    else:
        lattice_state = "Uncertain_Trust_State"
    # 12. Upgrade severity if surrounding distortion is high
    distortion_stack = average([
        parallax_error,
        attribution_warp,
        compression_error,
        sponsor_pressure,
        vocabulary_drift,
        accepted_reality_drift
    ])
    if lattice_state == "Neutral_or_Boundary_Trust_Lattice" and distortion_stack >= 0.55:
        lattice_state = "Negative_Trust_Lattice_Early"
    # 13. Select repair routes
    repair_routes = []
    if anchors["evidence_contact"] < 0.50:
        repair_routes.append("Evidence_Reanchor")
    if vocabulary_drift >= 0.50:
        repair_routes.append("Vocabulary_Repair")
    if sponsor_pressure >= 0.50:
        repair_routes.append("Sponsor_Disclosure")
    if anchors["repair_capacity"] < 0.50:
        repair_routes.append("Correction_Channel_Protection")
    if compression_error >= 0.50:
        repair_routes.append("Emergency_Or_Rule_Decompression")
    if parallax_error >= 0.35 or attribution_warp >= 0.50:
        repair_routes.append("Cross_Frame_Recalibration")
    if accepted_reality_drift >= 0.50:
        repair_routes.append("Accepted_Reality_Drift_Monitoring")
    if "Negative" in lattice_state:
        repair_routes.append("Ledger_Reconciliation")
    # 14. Return board output
    return {
        "event_core": event_core,
        "claim": claim,
        "frame": frame,
        "event_claim_gap": event_claim_gap,
        "local_trust_zero": local_trust_zero,
        "actual_trust_zero_band": actual_trust_zero_band,
        "trust_zero_drift": trust_zero_drift,
        "parallax_error": parallax_error,
        "attribution_warp": attribution_warp,
        "compression_error": compression_error,
        "sponsor_pressure": sponsor_pressure,
        "vocabulary_drift": vocabulary_drift,
        "accepted_reality_drift": accepted_reality_drift,
        "distortion_stack": distortion_stack,
        "lattice_state": lattice_state,
        "repair_routes": repair_routes,
        "ledger_required": "Negative" in lattice_state or distortion_stack >= 0.55
    }
def average(values):
    values = list(values)
    if not values:
        return 0.0
    return sum(values) / len(values)
def measure_gap(event_core, claim, frame):
    """
    Placeholder for event-claim-frame divergence.
    In a full runtime, this would compare verified event fields
    against claim expansion and narrative load.
    """
    return "requires_structured_event_claim_comparison"
def measure_parallax(
    inside_view,
    outside_view,
    victim_view,
    future_generation_view,
    historical_view,
    actor_reversal_view
):
    views = [
        inside_view,
        outside_view,
        victim_view,
        future_generation_view,
        historical_view,
        actor_reversal_view
    ]
    return max(views) - min(views)

Article_Lock:
  title: How to Use the Trust Zero Pin Runtime Board
  subtitle: >
    A Worked Example of Negative Trust Zero, Parallax Error,
    Sponsor Pressure, and Trust Re-Pinning
  core_object:
    name: Trust Zero Pin Runtime Board
    id: TZP_RB
  central_question: >
    Is this society still trusting from Actual Zero,
    or has misinformation moved Local Trust Zero into the Negative Lattice?
  main_method:
    - separate_event_from_narrative
    - identify_local_trust_zero
    - calculate_actual_trust_zero_band
    - measure_trust_zero_drift
    - detect_parallax_error
    - detect_civilisation_attribution_warp
    - detect_compression_error
    - detect_sponsor_pressure
    - detect_vocabulary_drift
    - detect_accepted_reality_drift
    - classify_lattice_state
    - route_trust_repinning
    - write_ledger_entry
  key_sentence: >
    The Trust Zero Pin Runtime Board does not ask only whether a claim is true;
    it asks whether the trust ruler used to judge the claim has already moved.
  next_stack_article:
    title: Trust Re-Pinning Protocol v1.0
    purpose: >
      Define the full repair system for moving Local Trust Zero back toward
      the Actual Trust Zero Band after misinformation, sponsor pressure,
      parallax error, or language drift has shifted the ruler.