SYSTEM: World Education OS
PAGE: W5 — Global Repair Mechanisms Library (GR*)
REFERENCE: CivOS (P0–P3, Z0–Z7)
PURPOSE:
  Provide canonical, reusable repair mechanisms
  that reduce variance, shrink tails, shorten repair latency,
  and improve transfer + timed execution reliability.
USAGE:
  Every City instance must list dominant GR* used/needed.
  Every Comparative must specify exports as GR* sets A→B and B→A.

REPAIR RULE (LOCK):
  A repair is "valid" only if it is:
    - describable as a loop
    - verifiable by sensors (P-S*, G-M*)
    - repeatable across contexts (exportable)

GR_SCHEMA:
  ID: GR<number>
  NAME: <short>
  MECHANISM: <one-line physics>
  INPUT CONDITIONS: {GF* triggers, stage E*, phase P*}
  LOOP STEPS: {step1, step2, step3}
  PROOF SENSORS: {P-S*, G-M*}
  FAILURE IF MISUSED: <how it backfires>

ID: GR1
NAME: Buffer Build Loop
MECHANISM: build concept spine + spaced retrieval → reduces brittleness → improves transfer
INPUT CONDITIONS: {GF2, GF3, GF9}, {E2–E6}, {P0–P2}
LOOP STEPS:
  1) identify smallest core concept set
  2) master to retrieval (no cues)
  3) space + revisit until stable
PROOF SENSORS: {P-S1, P-S4, G-M6, G-M3}
FAILURE IF MISUSED: volume without concept → reinforces GF2

ID: GR2
NAME: Error-Log Loop
MECHANISM: classify errors → remove repeats → stability rises under time
INPUT CONDITIONS: {GF6, GF7}, {E2–E6}, {P0–P2}
LOOP STEPS:
  1) log every error with category tag
  2) fix root cause with micro-drill
  3) retest timed until repeat rate collapses
PROOF SENSORS: {P-S2, P-S5, G-M5}
FAILURE IF MISUSED: logging without retest → no closure

ID: GR3
NAME: Transfer Loop
MECHANISM: same concept across new wrappers → transfer reliability increases
INPUT CONDITIONS: {GF2, GF9}, {E2–E6}, {P1–P2}
LOOP STEPS:
  1) generate 3–5 wrapper variants of same concept
  2) mixed practice with structure (not random)
  3) weekly transfer audit and patch weak wrappers
PROOF SENSORS: {P-S4, G-M6}
FAILURE IF MISUSED: too much novelty too early → overload (GF5)

ID: GR4
NAME: Time-Pressure Loop
MECHANISM: timed micro-sets + recovery protocol → reduces timed collapse volatility
INPUT CONDITIONS: {GF6, GF3}, {exam ramps}, {P1–P2}
LOOP STEPS:
  1) micro-timed sets at controlled difficulty
  2) enforce checking + recovery steps after mistakes
  3) raise speed floor while keeping accuracy floor
PROOF SENSORS: {P-S3, P-S5, G-M5}
FAILURE IF MISUSED: speed-only training → careless-error density increases

ID: GR5
NAME: Language-Base Loop
MECHANISM: vocabulary retrieval + comprehension drills → unlocks all subjects downstream
INPUT CONDITIONS: {GF1}, {E0–E4}, {P0–P2}
LOOP STEPS:
  1) daily retrieval of high-utility vocabulary
  2) comprehension parsing drills (questions → answer extraction)
  3) short output tasks (write/speak) to enforce active recall
PROOF SENSORS: {P-S1, P-S4, G-M2, G-M6}
FAILURE IF MISUSED: passive reading only → slow gains, weak output

ID: GR6
NAME: Continuity Loop
MECHANISM: stabilise routines → consolidation time appears → retention improves
INPUT CONDITIONS: {GF11, GF7}, {E0–E6}, {P0–P2}
LOOP STEPS:
  1) define daily minimum (low-friction)
  2) lock time windows + reduce schedule volatility
  3) weekly consolidation review to prevent reset cycles
PROOF SENSORS: {G-M3, P-S4, P-S5}
FAILURE IF MISUSED: overly strict plan → rebound collapse (GF12)

ID: GR7
NAME: Tail Visibility Protocol
MECHANISM: expose tails → route repair earlier → prevent hidden collapse pockets
INPUT CONDITIONS: {GF4, GF10}, {system-level}, {Z5/Z6}
LOOP STEPS:
  1) publish variance spread + tail thickness (not just means)
  2) tag clusters by repair latency
  3) require follow-up closure metrics
PROOF SENSORS: {G-M1, G-M2, G-M3}
FAILURE IF MISUSED: visibility without action → narrative warfare (GF10)

ID: GR8
NAME: Early-Warning Thresholds
MECHANISM: trigger repair before ramps → prevents compression cliffs
INPUT CONDITIONS: {GF3, GF5, GF7}, {pre-exam ramps}, {P0–P2}
LOOP STEPS:
  1) define thresholds (timed gap, transfer gap, volatility)
  2) trigger compulsory repair window
  3) verify closure before ramp continues
PROOF SENSORS: {G-M3, G-M4, P-S5}
FAILURE IF MISUSED: thresholds too strict → overload; too loose → late repair persists

ID: GR9
NAME: Cluster Targeting Protocol
MECHANISM: allocate repair capacity to tail clusters → variance shrinks systemically
INPUT CONDITIONS: {GF4, GF8}, {Z5/Z6}, {divergent cities}
LOOP STEPS:
  1) identify clusters via tail thickness + repair latency
  2) assign specialist repair capacity to clusters
  3) measure tail shrink + latency reduction
PROOF SENSORS: {G-M1, G-M2, G-M3}
FAILURE IF MISUSED: political routing overrides need → no measurable change

ID: GR10
NAME: Standardised Repair Protocols
MECHANISM: common repair language → repairs survive teacher turnover and system churn
INPUT CONDITIONS: {GF10, GF11}, {divergent systems}, {E0–E6}
LOOP STEPS:
  1) define core loops (GR1–GR4) as default repair set
  2) require sensor proofs before declaring success
  3) maintain continuity across teachers/grades
PROOF SENSORS: {G-M3, P-S4, P-S5}
FAILURE IF MISUSED: protocol without training → checkbox compliance (GF10)

ID: GR11
NAME: Pressure-Safety Scheduling
MECHANISM: cap load below recovery capacity → prevents burnout tail
INPUT CONDITIONS: {GF12}, {ramps/high-pressure tracks}, {P1–P3}
LOOP STEPS:
  1) measure load + sleep debt risk proxies
  2) enforce consolidation windows
  3) reintroduce intensity only after stability returns
PROOF SENSORS: {P-S5 volatility reduction, tail shrink in G-M2}
FAILURE IF MISUSED: under-loading → stagnation; must be calibrated

ID: GR12
NAME: Algebra Readiness Stabilisation
MECHANISM: secure algebra spine → prevents middle→high school cliff
INPUT CONDITIONS: {GF5, GF9}, {E3–E4}, {P0–P2}
LOOP STEPS:
  1) lock core algebra primitives (expressions, equations, functions)
  2) verify transfer across worded/graphical forms
  3) timed micro-sets + error-log closure
PROOF SENSORS: {P-S4, P-S5, G-M6}
FAILURE IF MISUSED: topic hopping → no spine forms

SYSTEM: World Education OS
LIBRARY: W5 GR Repair Library
REFERENCE: CivOS (P0–P3)
PRIMARY PURPOSE:
  Provide global repair mechanisms (GR1–GR12) with:
    - definition
    - required sensor basis
    - protocol (what to do)
    - proof-of-fix metrics (what must change)
    - typical linked failures (GF mapping)

GLOBAL PHASE SENSORS (P-S*):
  P-S1 retrieval reliability
  P-S2 error histogram
  P-S3 time-to-solve distribution
  P-S4 transfer under wrapper variation
  P-S5 timed stability variance
SYSTEM OUTPUTS (G-M*):
  G-M2 tail thickness
  G-M3 repair latency
  G-M5 timed vs untimed gap
  G-M6 transfer gap under novelty
  G-M7 masking factor

GR_ID: GR1
NAME: Buffer Build Loop
DEFINITION:
  Convert fragile knowledge into stable “spine mastery” via small-set mastery + spaced retrieval.
REQUIRED SENSORS:
  P-S1, P-S2, P-S4 (transfer improves when spine is real), G-M3 (latency)
PROTOCOL:
  1) Identify minimal spine set (core primitives)
  2) Train to retrieval-without-cues
  3) Space and revisit until decay stops
  4) Freeze expansion until stability holds
PROOF-OF-FIX:
  - P-S1 increases and stays stable across weeks
  - P-S2 repeat errors decline
  - G-M3 repair latency shortens for same topic family
TYPICAL GF LINKS:
  {GF2, GF3, GF5, GF9, GF11}

GR_ID: GR2
NAME: Error-Log Closure Loop
DEFINITION:
  Reduce failure probability by collapsing repeat-error density via classification + targeted micro-drills.
REQUIRED SENSORS:
  P-S2 (error histogram), OL-S5 analog, G-M3
PROTOCOL:
  1) Tag errors by root cause class (concept/execution/misread/transfer)
  2) Micro-drill the root cause (not the whole topic)
  3) Retest under the same conditions where it failed (timed/unseen)
  4) Repeat until that error class disappears
PROOF-OF-FIX:
  - repeat-error density declines week-to-week
  - P-S2 shifts from repeat clusters → scattered rare errors
  - G-M3 latency decreases for the same failure class
TYPICAL GF LINKS:
  {GF2, GF6, GF9, GF11}

GR_ID: GR3
NAME: Transfer Loop
DEFINITION:
  Increase robustness by training the same concept across varied wrappers (worded/diagram/graph/context).
REQUIRED SENSORS:
  P-S4, G-M6, P-S2 (wrong-method clusters)
PROTOCOL:
  1) Identify concept family
  2) Generate wrapper set (3+ forms)
  3) Train recognition → method selection → execution across wrappers
  4) Add mixed sets to force correct choice
PROOF-OF-FIX:
  - P-S4 increases on unseen wrappers
  - G-M6 transfer gap decreases
  - P-S2 wrong-method/wrong-interpretation cluster declines
TYPICAL GF LINKS:
  {GF1, GF2, GF9}

GR_ID: GR4
NAME: Time-Pressure Loop
DEFINITION:
  Convert untimed competence into timed reliability by training stable speed + recovery behaviour.
REQUIRED SENSORS:
  P-S3, P-S5, G-M5, P-S2 (execution errors under time)
PROTOCOL:
  1) Timed micro-sets with stable pacing
  2) Teach recovery protocol:
      stop → re-read → choose method → execute → quick check
  3) Expand to mixed half-papers → full papers
  4) Lock “no-rushing” discipline (stable speed)
PROOF-OF-FIX:
  - G-M5 timed gap decreases
  - P-S5 volatility decreases across timed papers
  - P-S3 time distribution stabilises (fewer extreme slow/fast spikes)
TYPICAL GF LINKS:
  {GF3, GF6, GF7, GF12}

GR_ID: GR5
NAME: Language-Base Loop
DEFINITION:
  Fix cross-subject failure caused by misread prompts, weak parsing, and imprecise vocabulary.
REQUIRED SENSORS:
  P-S4 (worded transfer), P-S2 (misread clusters), G-M6
PROTOCOL:
  1) Command-word mapping (what the question wants)
  2) Sentence parsing drills (subject/verb/object, constraints)
  3) Vocabulary precision training (meaning + usage)
  4) Compliance rewrites: rewrite answers to match prompt
PROOF-OF-FIX:
  - command-word compliance increases
  - G-M6 transfer gap decreases on worded wrappers
  - P-S2 misread clusters shrink
TYPICAL GF LINKS:
  {GF1, GF9}

GR_ID: GR6
NAME: Continuity Loop
DEFINITION:
  Prevent “reset cycles” by enforcing minimum weekly outputs + consolidation windows.
REQUIRED SENSORS:
  P-S1 decay checks, P-S2 repeat recurrence, G-M3 cyclic latency
PROTOCOL:
  1) Set weekly minimums (small, non-negotiable)
  2) Insert consolidation windows (review + retrieval)
  3) Prevent long gaps
  4) Detect regression early and re-stabilise
PROOF-OF-FIX:
  - P-S1 stays stable across weeks
  - P-S2 repeats do not reappear after breaks
  - G-M3 becomes shorter and non-cyclic
TYPICAL GF LINKS:
  {GF11, GF7, GF12}

GR_ID: GR7
NAME: Tail Visibility Protocol
DEFINITION:
  Make hidden failure pockets visible by publishing tails (G-M2) and independence proofs,
  reducing masking (G-M7).
REQUIRED SENSORS:
  G-M2, G-M7, G-M3
PROTOCOL:
  1) Measure tails explicitly (bottom decile performance stability)
  2) Require independent proof outputs (no scaffolds)
  3) Track masking factor and remove dependency paths
  4) Publish tail movements, not just averages
PROOF-OF-FIX:
  - G-M2 tails shrink
  - G-M7 masking decreases
  - G-M3 latency shortens for tail clusters
TYPICAL GF LINKS:
  {GF4, GF7, GF8, GF10}

GR_ID: GR8
NAME: Early-Warning Thresholds
DEFINITION:
  Prevent cliff failures by triggering repairs when metrics cross thresholds, before ramps.
REQUIRED SENSORS:
  G-M3, G-M5, G-M6, P-S5, G-M2
PROTOCOL:
  1) Define thresholds (timed gap, transfer gap, volatility, latency)
  2) Monitor weekly
  3) Trigger targeted GR loops immediately when crossed
  4) Require proof-of-fix before returning to ramp
PROOF-OF-FIX:
  - fewer cliff failures at gates
  - G-M3 latency decreases pre-ramp
  - P-S5 volatility decreases near gates
TYPICAL GF LINKS:
  {GF3, GF5, GF6, GF7, GF12}

GR_ID: GR9
NAME: Cluster Targeting Protocol
DEFINITION:
  Route resources/interventions to the clusters producing tails and long latency, not averages.
REQUIRED SENSORS:
  G-M1, G-M2, G-M3
PROTOCOL:
  1) Identify tail clusters (schools/regions/streams)
  2) Diagnose dominant GF clusters per cluster
  3) Deploy matching GR loops
  4) Measure tail shrink and latency reduction per cluster
PROOF-OF-FIX:
  - G-M2 tails shrink by cluster
  - G-M3 latency shortens in targeted clusters
  - variance spread (G-M1) narrows
TYPICAL GF LINKS:
  {GF4, GF7, GF8}

GR_ID: GR10
NAME: Standardised Repair Protocols
DEFINITION:
  Turn effective repairs into portable protocols so execution quality does not depend on individual teachers.
REQUIRED SENSORS:
  G-M3 (latency), P-S2 (repeat reduction), G-M1 (variance)
PROTOCOL:
  1) Define standard repair recipes (GR1–GR4 combos)
  2) Specify inputs/steps/proofs
  3) Train operators to run protocols consistently
  4) Audit fidelity using sensors
PROOF-OF-FIX:
  - reduced variance (G-M1)
  - shorter repair latency (G-M3)
  - repeat errors decline system-wide
TYPICAL GF LINKS:
  {GF4, GF10, GF8}

GR_ID: GR11
NAME: Pressure-Safety Scheduling
DEFINITION:
  Keep load below recovery capacity to prevent fatigue-driven regression (burnout tail).
REQUIRED SENSORS:
  P-S5 volatility, P-S3 slowdown+errors, G-M2 tail thickening near ramps
PROTOCOL:
  1) Cap workload and protect sleep/consolidation
  2) Use shorter, higher-quality sessions
  3) Insert recovery days; avoid “panic marathons”
  4) Resume ramps only after stability returns
PROOF-OF-FIX:
  - volatility decreases (P-S5)
  - tail thickening stops (G-M2)
  - timed stability improves (G-M5 decreases)
TYPICAL GF LINKS:
  {GF12, GF6, GF3}

GR_ID: GR12
NAME: Algebra Readiness Stabilisation
DEFINITION:
  Protect transition jumps (especially Sec2→Sec3) by stabilising algebra substrate and abstraction readiness.
REQUIRED SENSORS:
  (subject) algebra integrity index, G-M4 transition clustering, G-M3 latency post-transition
PROTOCOL:
  1) Identify minimal algebra primitives needed for next regime
  2) Train to retrieval + low error manipulation
  3) Verify transfer across algebra wrappers (worded/symbolic/graphical)
  4) Only then allow content acceleration
PROOF-OF-FIX:
  - transition shock clustering reduces (G-M4)
  - post-transition repair latency decreases (G-M3)
  - chain-break probability decreases in multi-step tasks
TYPICAL GF LINKS:
  {GF5, GF3, GF6}

MAPPING REQUIREMENT:
  City instance must declare:
    DOMINANT_GR_EXPORTS: {GR*...} (top 5 used/needed)
  Comparative must declare:
    GR_EXPORTS_A_TO_B: {GR*...} with proof sensors required
    GR_EXPORTS_B_TO_A: {GR*...} with proof sensors required

LOCK:
  W5 is the repair engine.
  W4 names failures; W5 fixes them.
  Adoption requires proof: G-M2 (tails) + G-M3 (latency) plus timed/transfer stability shifts.
  GR* is the universal repair dictionary.
  Repairs become global when they are defined as loops + sensor proofs.
  This is how “education reform” becomes engineering:
    detect → repair → verify → repeat.