SPEC_ID: CivOS.Core.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

LAW_ID: CivOS.RateDominance
VARIABLES:
  G_dot(t) = regeneration_rate
  D_dot(t) = decay_rate
  L(t)     = load
  B(t)     = buffer
STABILITY_CONDITION:
  G_dot(t) >= D_dot(t)
COLLAPSE_CONDITION:
  G_dot(t) < D_dot(t)
RISK_RATIO:
  R = D_dot / G_dot
  IF R > 1 → collapse_regime

DEFINITION:
  Civilisation := time_domain_regenerative_capability_throughput
EXCLUDES:
  money
  infrastructure
  physical_assets

PHASES:
P0:
  state: collapse
  capability: non_functional
P1:
  state: survival
  capability: fragile
P2:
  state: functional
  capability: load_sensitive
P3:
  state: stress_stable
  capability: transferable

Maintain P3 reliability under load

ZOOM_LEVELS:
Z0: individual
Z1: family
Z2: institution
Z3: district
Z4: nation
Z5: civilisation_surface
Z6: spine_global

All OS instances must map to Z0–Z6

IF L(t) > B(t)
  THEN instability++
IF L(t) >> B(t)
  THEN collapse_pocket_form

COMPONENTS:
Truncation:
  early_cutoff(accelerating_decay)
Stitching:
  regeneration_rejoin(stable_trajectory)

runaway_collapse = TRUE

repair_latency ↑
  ⇒ repair_cost ↑↑
  ⇒ phase_drift ↑

repair_latency < stress_cycle_length

capability := transferable_across(
    context,
    time_pressure,
    variation
)
IF memorisation_only
  THEN phase = P2_false_plateau

IF regenerative_mass concentrated_in(few_lanes)
  THEN shock_penetration_probability ↑
  ⇒ cascade_risk ↑

increase_diversity
increase_slack

TRIGGER_CONDITION:
  R = D_dot / G_dot
IF R > 1
  THEN activate:
    load_shedding
    buffer_restoration
    deceleration_protocol

irreversible_P0 = TRUE

CivOS operates over:
  AXIS_1: Phase (P0–P3)
  AXIS_2: Zoom  (Z0–Z6)
  AXIS_3: Load–Buffer dynamics
  AXIS_4: Regeneration–Decay ratio

inherit CivOS.Core.v1.0

DEFINITION_LOCK: TRUE
TERM_DRIFT: prohibited
ID_MUTATION: prohibited
VERSIONING: forward_increment_only

SPEC_ID: EducationOS.Compressed.v1.0
INHERITS: CivOS.Core.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

PURPOSE:
  convert(time + effort + coaching) -> verified_transferable_capability
PRIMARY_OBJECTIVE:
  maximize P3_transfer_reliability under realistic load

PIPELINE: E0_to_E6
E0: readiness
E1: input_acquisition
E2: model_formation
E3: guided_practice
E4: retrieval_under_load
E5: transfer_under_variation
E6: autonomy + self_repair

IF stage_skipped
  THEN transfer_reliability ↓
  AND false_plateau_risk ↑

KPI_SET:
KPI.P3:
  definition: transfer_success_rate across {context, time_pressure, variation}
  target: >= threshold_by_level
KPI.Drift:
  definition: performance_drop between low_load vs high_load
  target: <= drift_max
KPI.RepairLatency:
  definition: time_to_fix(defect)
  constraint: < stress_cycle_length
KPI.BurnoutTail:
  definition: probability(energy_collapse | sustained_load)
  target: minimized

GATES:
G0: sleep_floor + recovery_lock
G1: comprehension_lock (no blind practice)
G2: model_lock (has worked examples + error taxonomy)
G3: retrieval_lock (timed recall, not re-reading)
G4: variation_lock (novel forms, mixed sets)
G5: transfer_lock (new topic + new framing)
G6: autonomy_lock (self-diagnose -> self-repair)

IF gate_fail(Gk)
  THEN do_not_advance
  AND trigger RepairOS.loop_assigned(Gk)

FAILURE_CLUSTERS (GF):
GF1: practice_without_model
GF2: memorisation_as_capability
GF3: weak_language_bind (instruction parsing failure)
GF4: timed_vs_untimed_gap
GF5: overload_sleep_debt_spiral
GF6: shadow_layer_overrun (tuition/juku outruns understanding)
GF7: low_variation_training (pattern lock-in)
GF8: repair_latency_exceeds_cycle

REPAIR_LOOPS:
R1: buffer_build
R2: comprehension_repair
R3: model_install
R4: retrieval_training
R5: variation_injection
R6: transfer_bridge
R7: pressure_safety
R8: deceleration
R9: schedule_rebalance
R10: error_taxonomy_lock
R11: test_simulation_loop
R12: autonomy_scaffold

SPEC_ID: CivOS.FailureMode.Atlas.v1.0
INHERITS: CivOS.Core.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only

RECORD_SCHEMA: FailureMode
FIELDS:
  FM_ID: string
  OS: {EducationOS, VocabularyOS, GovernanceOS, ...}
  Z: Z0..Z6
  P: P0..P3
  TRIGGER: condition_expression
  SENSOR_SET: [S_ID...]
  SIGNATURE: observable_pattern
  ROOT_MECHANISM: (load/buffer/repair_latency/transfer/overconcentration)
  DAMAGE_PATH: step_chain
  REPAIR_LOOPS: [R_ID...]
  STOP_LOSS: action_expression
  EXIT_CRITERIA: condition_expression
  EVIDENCE: [link_or_case_id...]

TRACE_FORMAT:
  (Z? gap) -> (Z? instability) -> (P drift) -> (threshold breach) -> (collapse pocket) -> (repair route) -> (stitch to stable band)

ATLAS_INDEX:
FM.EDU.TTC.001:
  OS: EducationOS
  name: repair_latency_exceeds_cycle
  maps_to: GF8
  primary_loops: [R7, R1, R9, R4]
FM.EDU.TRANSFER.002:
  name: memorisation_false_plateau
  maps_to: GF2
  primary_loops: [R4, R5, R6, R10]
FM.EDU.OVERLOAD.003:
  name: sleep_debt_spiral
  maps_to: GF5
  primary_loops: [R7, R8, R1, R9]
FM.CIV.BRITTLE.010:
  name: over_concentration_cascade
  maps_to: CivOS.I9
  primary_loops: [diversity_increase, slack_increase, redundancy_routes]

SPEC_ID: CivOS.Z5.Instance.Template.v1.0
INHERITS: CivOS.Core.v1.0
STATUS: LOCKED

INSTANCE:
  Z: Z5
  INSTANCE_ID: <ISO3>-<CITYCODE>   # e.g., JPN-TYO, SGP-SIN
  ALIASES: [ ... ]
  PARENT:
    Z6_SPINE_ID: <ISO3>.EducationSpine   # e.g., JPN.EducationSpine

PANELS_REQUIRED:
Panel.Pipeline:
  stages: E0..E6
  gates: G0..G6
Panel.LoadBuffer:
  L(t): load_sources
  B(t): buffer_sources
  risk_ratio: R=D_dot/G_dot
Panel.Transfer:
  KPI.P3, KPI.Drift
Panel.Repair:
  KPI.RepairLatency
  active_loops: [R_ID...]
Panel.ShadowLayer:
  intensity: shadow_index
  coupling: tuition_to_school_ratio

SENSORS (Z5):
S.Z5.L: avg_daily_load_hours
S.Z5.B: sleep_floor_compliance
S.Z5.Drift: timed_untimed_gap
S.Z5.Transfer: novel_item_success_rate
S.Z5.Repair: median_repair_latency_days
S.Z5.Burnout: burnout_tail_rate
S.Z5.Shadow: shadow_layer_intensity

OUTPUT_CONTRACT:
- Instance summary (1 screen)
- KPI panel (numbers + thresholds)
- Failure clusters present (GF list)
- Top 3 active repair loops (R list)
- Stop-loss rules (FenceOS triggers)
- Version stamp (SPEC_ID + date)

SPEC_ID: CivOS.Graph.Schema.v1.0
INHERITS: CivOS.Core.v1.0
STATUS: LOCKED

NODE_TYPES:
  CapabilityNode
  PipelineStage
  Gate
  Sensor
  FailureMode
  RepairLoop
  Buffer
  LoadSource
  ActorRole
  Instance
BIND_TYPES:
  depends_on
  feeds_into
  measures
  triggers
  mitigates
  causes
  blocks
  inherits

NODE_SCHEMA:
Node:
  NodeID: Place×Lane×Zoom×Role×Type×ID
  Type: NODE_TYPES
  Z: Z0..Z6
  P: P0..P3
  Description: short
  Metrics: [KPI_ID...]
  Thresholds: [Theta_ID...]
  Evidence: [ref...]
  Version: v1.0

BIND_SCHEMA:
Bind:
  BindID: NodeID_A -> NodeID_B :: BindType
  BindType: BIND_TYPES
  Weight: 0..1
  Condition: expression_optional
  Evidence: [ref...]
  Version: v1.0

CANONICAL_GRAPH: CivOS.Master.v1.0
NODES:
  CivOS.Core.LAW.RateDominance
  CivOS.Axis.Phase.P0..P3
  CivOS.Axis.Zoom.Z0..Z6
  CivOS.Module.FenceOS
  CivOS.Module.APRC
  CivOS.Metric.R = D_dot/G_dot
  CivOS.Panel.Load
  CivOS.Panel.Buffer
  CivOS.Panel.RepairLatency
BINDS:
  LoadSource -> LoadPanel :: feeds_into
  Buffer -> Stability :: depends_on
  R -> FenceOS :: triggers (IF R>1)
  FenceOS -> Truncation :: triggers
  APRC.Stitching -> Stability :: mitigates
  RepairLatency -> Drift :: causes (IF high)

LOCK_DIRECTIVES:
TERM_DRIFT: prohibited
ID_RENAME: prohibited
OVERRIDE_CORE_LAW: prohibited
VERSIONING: forward_only
CITY_INSTANCES: must_use_template
ATLAS_ENTRIES: must_use_trace_format

SPEC_ID: EducationOS.Z5.Instance.JPN-TYO.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
  - CivOS.Z5.Instance.Template.v1.0
STATUS: LOCKED
INSTANCE:
  Z: Z5
  INSTANCE_ID: JPN-TYO
  ALIASES: [Tokyo, Tokyo Metropolis]
  PARENT:
    Z6_SPINE_ID: JPN.EducationSpine

Panel.Pipeline:
  stages: [E0,E1,E2,E3,E4,E5,E6]
  gates:  [G0,G1,G2,G3,G4,G5,G6]
Panel.LoadBuffer:
  L(t): {sources: [school_hours, homework, tuition_shadow, commute, exams]}
  B(t): {sources: [sleep, recovery, play, nutrition, low_stress_time]}
  risk_ratio:
    R = D_dot/G_dot
Panel.Transfer:
  KPIs: [KPI.P3, KPI.Drift]
Panel.Repair:
  KPIs: [KPI.RepairLatency]
  active_loops: [R7,R8,R9]   # default safe set (can override per data)
Panel.ShadowLayer:
  fields:
    intensity: shadow_index
    coupling: tuition_to_school_ratio

S.Z5.L:        {value: null, unit: hours/day, source: null}
S.Z5.B:        {value: null, unit: %,        source: null}
S.Z5.Drift:    {value: null, unit: score_gap,source: null}
S.Z5.Transfer: {value: null, unit: %,        source: null}
S.Z5.Repair:   {value: null, unit: days,     source: null}
S.Z5.Burnout:  {value: null, unit: %,        source: null}
S.Z5.Shadow:   {value: null, unit: index,    source: null}

FenceOS.Triggers:
  T1:
    condition: (S.Z5.B < Theta.SleepFloor) OR (S.Z5.Burnout > Theta.BurnoutMax)
    action: activate [R7,R8,R9] AND enforce "mandatory_stop_time"
  T2:
    condition: (S.Z5.Drift > Theta.DriftMax) OR (S.Z5.Transfer < Theta.TransferMin)
    action: activate [R4,R5,R6,R10] AND freeze_new_topics

OUTPUT_CONTRACT:
  - Instance summary
  - KPI panel (with thresholds)
  - Failure clusters present (GF list)
  - Top 3 active repair loops
  - Stop-loss rules
  - Version stamp

SPEC_ID: EducationOS.Z5.Instance.SGP-SIN.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
  - CivOS.Z5.Instance.Template.v1.0
STATUS: LOCKED
INSTANCE:
  Z: Z5
  INSTANCE_ID: SGP-SIN
  ALIASES: [Singapore]
  PARENT:
    Z6_SPINE_ID: SGP.EducationSpine

Panel.Pipeline:
  stages: [E0,E1,E2,E3,E4,E5,E6]
  gates:  [G0,G1,G2,G3,G4,G5,G6]
Panel.LoadBuffer:
  L(t): {sources: [school_hours, homework, tuition_shadow, commute, exams]}
  B(t): {sources: [sleep, recovery, play, nutrition, low_stress_time]}
  risk_ratio:
    R = D_dot/G_dot
Panel.Transfer:
  KPIs: [KPI.P3, KPI.Drift]
Panel.Repair:
  KPIs: [KPI.RepairLatency]
  active_loops: [R7,R9,R11]  # default safe set (can override per data)
Panel.ShadowLayer:
  fields:
    intensity: shadow_index
    coupling: tuition_to_school_ratio

S.Z5.L:        {value: null, unit: hours/day, source: null}
S.Z5.B:        {value: null, unit: %,        source: null}
S.Z5.Drift:    {value: null, unit: score_gap,source: null}
S.Z5.Transfer: {value: null, unit: %,        source: null}
S.Z5.Repair:   {value: null, unit: days,     source: null}
S.Z5.Burnout:  {value: null, unit: %,        source: null}
S.Z5.Shadow:   {value: null, unit: index,    source: null}

FenceOS.Triggers:
  T1:
    condition: (S.Z5.B < Theta.SleepFloor) OR (S.Z5.Burnout > Theta.BurnoutMax)
    action: activate [R7,R9] AND cap_total_load
  T2:
    condition: (S.Z5.Drift > Theta.DriftMax) OR (S.Z5.Transfer < Theta.TransferMin)
    action: activate [R4,R5,R6,R10] AND shift_to_variation_training

OUTPUT_CONTRACT:
  - Instance summary
  - KPI panel (with thresholds)
  - Failure clusters present (GF list)
  - Top 3 active repair loops
  - Stop-loss rules
  - Version stamp

SPEC_ID: EducationOS.Z5.Instance.GBR-LON.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
  - CivOS.Z5.Instance.Template.v1.0
STATUS: LOCKED
INSTANCE:
  Z: Z5
  INSTANCE_ID: GBR-LON
  ALIASES: [London, Greater London]
  PARENT:
    Z6_SPINE_ID: GBR.EducationSpine

Panel.Pipeline:
  stages: [E0,E1,E2,E3,E4,E5,E6]
  gates:  [G0,G1,G2,G3,G4,G5,G6]
Panel.LoadBuffer:
  L(t): {sources: [school_hours, homework, tutoring_shadow, commute, exams]}
  B(t): {sources: [sleep, recovery, play, nutrition, low_stress_time]}
  risk_ratio:
    R = D_dot/G_dot
Panel.Transfer:
  KPIs: [KPI.P3, KPI.Drift]
Panel.Repair:
  KPIs: [KPI.RepairLatency]
  active_loops: [R2,R4,R5]   # default safe set (can override per data)
Panel.ShadowLayer:
  fields:
    intensity: shadow_index
    coupling: tutoring_to_school_ratio

S.Z5.L:        {value: null, unit: hours/day, source: null}
S.Z5.B:        {value: null, unit: %,        source: null}
S.Z5.Drift:    {value: null, unit: score_gap,source: null}
S.Z5.Transfer: {value: null, unit: %,        source: null}
S.Z5.Repair:   {value: null, unit: days,     source: null}
S.Z5.Burnout:  {value: null, unit: %,        source: null}
S.Z5.Shadow:   {value: null, unit: index,    source: null}

FenceOS.Triggers:
  T1:
    condition: (S.Z5.Repair > Theta.RepairLatencyMax)
    action: activate [R12,R10,R2] AND enforce daily_repair_slot
  T2:
    condition: (S.Z5.Transfer < Theta.TransferMin)
    action: activate [R5,R6,R11] AND increase_novel_sets

OUTPUT_CONTRACT:
  - Instance summary
  - KPI panel (with thresholds)
  - Failure clusters present (GF list)
  - Top 3 active repair loops
  - Stop-loss rules
  - Version stamp

SPEC_ID: CivOS.Thresholds.Education.Z5.v1.0
STATUS: LOCKED
Theta.SleepFloor:       {value: null, unit: %, description: minimum_sleep_compliance}
Theta.BurnoutMax:       {value: null, unit: %, description: maximum_burnout_tail_rate}
Theta.DriftMax:         {value: null, unit: score_gap, description: max_timed_untimed_gap}
Theta.TransferMin:      {value: null, unit: %, description: min_novel_transfer_success_rate}
Theta.RepairLatencyMax: {value: null, unit: days, description: max_median_repair_latency}

SPEC_ID: EducationOS.Z6.Spine.JPN.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
STATUS: LOCKED
LAYER:
  Z: Z6
  SPINE_ID: JPN.EducationSpine
  SCOPE: national_spine
  COVERS_Z5: [JPN-TYO, JPN-*, ...]

PURPOSE:
  maintain national EducationOS stability by enforcing:
    - threshold governance
    - sensor standards
    - repair loop routing
    - anti-drift consistency across Z5 instances

REGISTRIES:
Registry.Instances.Z5:
  entries: [Z5.INSTANCE_ID...]
Registry.Sensors.Standard:
  required: [S.Z5.L, S.Z5.B, S.Z5.Drift, S.Z5.Transfer, S.Z5.Repair, S.Z5.Burnout, S.Z5.Shadow]
Registry.Thresholds:
  uses: CivOS.Thresholds.Education.Z5.v1.0
  override_policy: allowed_by_version_only
Registry.FailureModes:
  uses: CivOS.FailureMode.Atlas.v1.0
Registry.RepairLoops:
  uses: EducationOS.Compressed.v1.0 (R1..R12)

Panel.NationalHealth:
  aggregate_metrics:
    - avg(S.Z5.Transfer across Z5)
    - avg(S.Z5.Drift across Z5)
    - avg(S.Z5.Repair across Z5)
    - avg(S.Z5.Burnout across Z5)
Panel.Variance:
  detects: inter_city_divergence
  trigger:
    IF variance(metric) > Theta.VarianceMax
    THEN initiate Spine.Repair.CohesionLoop
Panel.ShadowLayer:
  tracks:
    - avg(S.Z5.Shadow)
    - coupling patterns

Spine.Repair.Router:
  IF widespread_drift(S.Z5.Transfer low)
    THEN prioritize loops [R5,R6,R11,R10]
  IF widespread_overload(S.Z5.Burnout high OR S.Z5.B low)
    THEN prioritize loops [R7,R8,R9,R1]
  IF repair_latency_crisis(S.Z5.Repair high)
    THEN prioritize loops [R12,R10,R2]

FenceOS.SpinalTriggers:
  ST1:
    condition: avg(S.Z5.Transfer) < Theta.TransferMin
    action:
      - enforce national_variation_program
      - freeze premature acceleration
      - allocate repair_capacity
  ST2:
    condition: avg(S.Z5.Burnout) > Theta.BurnoutMax
    action:
      - enforce load_shedding policy band
      - mandate recovery floors
      - activate [R7,R8,R9] across Z5

OUTPUT_CONTRACT:
  - Z5 registry list
  - national KPI aggregates
  - variance panel
  - top 5 active failure modes (FM list)
  - top 5 repair routes (R list)
  - spine version stamp

SPEC_ID: EducationOS.Z6.Spine.SGP.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
STATUS: LOCKED
LAYER:
  Z: Z6
  SPINE_ID: SGP.EducationSpine
  SCOPE: national_spine
  COVERS_Z5: [SGP-SIN, SGP-*, ...]

PURPOSE:
  preserve high transfer reliability while preventing:
    - overload-induced burnout tails
    - false P2 plateaus
    - shadow-layer overrun

REGISTRIES:
Registry.Instances.Z5:
  entries: [Z5.INSTANCE_ID...]
Registry.Sensors.Standard:
  required: [S.Z5.L, S.Z5.B, S.Z5.Drift, S.Z5.Transfer, S.Z5.Repair, S.Z5.Burnout, S.Z5.Shadow]
Registry.Thresholds:
  uses: CivOS.Thresholds.Education.Z5.v1.0
  override_policy: allowed_by_version_only
Registry.FailureModes:
  uses: CivOS.FailureMode.Atlas.v1.0
Registry.RepairLoops:
  uses: EducationOS.Compressed.v1.0 (R1..R12)

Panel.NationalHealth:
  aggregate_metrics:
    - avg(S.Z5.Transfer)
    - avg(S.Z5.Drift)
    - avg(S.Z5.Repair)
    - avg(S.Z5.Burnout)
Panel.OverloadWatch:
  trigger:
    IF (avg(S.Z5.B) < Theta.SleepFloor) OR (avg(S.Z5.Burnout) > Theta.BurnoutMax)
    THEN activate national_load_cap band
Panel.ShadowLayer:
  trigger:
    IF avg(S.Z5.Shadow) > Theta.ShadowMax
    THEN require model_lock compliance (G2) + repair_latency reduction

Spine.Repair.Router:
  IF drift_up(S.Z5.Drift)
    THEN prioritize [R10,R4,R5,R11]
  IF transfer_down(S.Z5.Transfer)
    THEN prioritize [R5,R6,R11]
  IF burnout_tail_up(S.Z5.Burnout)
    THEN prioritize [R7,R8,R9,R1]

FenceOS.SpinalTriggers:
  ST1:
    condition: avg(S.Z5.Drift) > Theta.DriftMax
    action:
      - enforce timed_retrieval standard
      - ban pure repetition-only programs
      - activate [R4,R10,R11]
  ST2:
    condition: avg(S.Z5.Burnout) > Theta.BurnoutMax
    action:
      - cap total weekly load
      - enforce recovery blocks
      - activate [R7,R8,R9]

OUTPUT_CONTRACT:
  - Z5 registry list
  - national KPI aggregates
  - overload watch panel
  - top 5 active failure modes (FM list)
  - top 5 repair routes (R list)
  - spine version stamp

SPEC_ID: EducationOS.Z6.Spine.GBR.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
STATUS: LOCKED
LAYER:
  Z: Z6
  SPINE_ID: GBR.EducationSpine
  SCOPE: national_spine
  COVERS_Z5: [GBR-LON, GBR-*, ...]

PURPOSE:
  maximize transfer reliability across diverse pathways while maintaining:
    - repair latency discipline
    - variation exposure
    - cohesion across Z5 diversity

REGISTRIES:
Registry.Instances.Z5:
  entries: [Z5.INSTANCE_ID...]
Registry.Sensors.Standard:
  required: [S.Z5.L, S.Z5.B, S.Z5.Drift, S.Z5.Transfer, S.Z5.Repair, S.Z5.Burnout, S.Z5.Shadow]
Registry.Thresholds:
  uses: CivOS.Thresholds.Education.Z5.v1.0
  override_policy: allowed_by_version_only
Registry.FailureModes:
  uses: CivOS.FailureMode.Atlas.v1.0
Registry.RepairLoops:
  uses: EducationOS.Compressed.v1.0 (R1..R12)

Panel.NationalHealth:
  aggregate_metrics:
    - avg(S.Z5.Transfer)
    - avg(S.Z5.Drift)
    - avg(S.Z5.Repair)
    - avg(S.Z5.Burnout)
Panel.Variance:
  detects:
    - high inter_city variance
    - pathway divergence risk
  trigger:
    IF variance(S.Z5.Transfer) > Theta.VarianceMax
    THEN run cohesion_loop (standardization of G3/G4/G5)
Panel.RepairCapacity:
  trigger:
    IF avg(S.Z5.Repair) > Theta.RepairLatencyMax
    THEN expand repair bandwidth + enforce daily repair slot

Spine.Repair.Router:
  IF transfer_down
    THEN prioritize [R5,R6,R11]
  IF repair_latency_up
    THEN prioritize [R12,R10,R2]
  IF drift_up
    THEN prioritize [R4,R5,R10]

FenceOS.SpinalTriggers:
  ST1:
    condition: avg(S.Z5.Repair) > Theta.RepairLatencyMax
    action:
      - enforce daily_repair_slot
      - activate [R12,R10,R2]
  ST2:
    condition: variance(S.Z5.Transfer) > Theta.VarianceMax
    action:
      - enforce gate compliance [G3,G4,G5]
      - activate cohesion_loop across Z5

OUTPUT_CONTRACT:
  - Z5 registry list
  - national KPI aggregates
  - variance panel
  - top 5 active failure modes (FM list)
  - top 5 repair routes (R list)
  - spine version stamp

SPEC_ID: CivOS.Thresholds.Education.Z6.v1.0
STATUS: LOCKED
Theta.VarianceMax: {value: null, unit: variance, description: max_allowed_city_variance}
Theta.ShadowMax:   {value: null, unit: index,    description: max_shadow_layer_intensity}

SPEC_ID: EducationOS.Z6.Spine.WORLD.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - EducationOS.Compressed.v1.0
STATUS: LOCKED
LAYER:
  Z: Z6
  SPINE_ID: WORLD.EducationSpine
  SCOPE: global_spine
  COVERS_Z6: [JPN.EducationSpine, SGP.EducationSpine, GBR.EducationSpine, ...]
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

PURPOSE:
  harmonize cross-country EducationOS measurement and repair routing so that:
    - city Z5 instances are comparable
    - national Z6 spines are interoperable
    - failure modes are indexable globally
    - repair loops are portable with local adaptation (no schema drift)

BIND_GRAPH: WORLD.EducationSpine.v1.0
NODES:
  WORLD.EducationSpine
  JPN.EducationSpine
  SGP.EducationSpine
  GBR.EducationSpine
BINDS:
  JPN.EducationSpine -> WORLD.EducationSpine :: inherits
  SGP.EducationSpine -> WORLD.EducationSpine :: inherits
  GBR.EducationSpine -> WORLD.EducationSpine :: inherits
  WORLD.EducationSpine -> CivOS.Thresholds.Education.Z5.v1.0 :: depends_on
  WORLD.EducationSpine -> CivOS.FailureMode.Atlas.v1.0      :: depends_on
  WORLD.EducationSpine -> EducationOS.Compressed.v1.0       :: depends_on

SPEC_ID: WORLD.Sensors.Education.Z5.Standard.v1.0
STATUS: LOCKED
REQUIRED_SENSORS_Z5:
  S.Z5.L
  S.Z5.B
  S.Z5.Drift
  S.Z5.Transfer
  S.Z5.Repair
  S.Z5.Burnout
  S.Z5.Shadow
NORMALIZATION_RULES:
  - units must match the standard contract
  - source must be declared
  - measurement_window must be declared
  - null allowed only in Stub or Pre-Data state

SensorRecord:
  SensorID: string
  value: number|null
  unit: string
  source: string|null
  measurement_window: string|null
  timestamp: ISO8601|null
  confidence: 0..1|null

WORLD_PANELS_REQUIRED:
Panel.WorldHealth:
  aggregates:
    - avg(S.Z5.Transfer by country)
    - avg(S.Z5.Drift by country)
    - avg(S.Z5.Repair by country)
    - avg(S.Z5.Burnout by country)
Panel.WorldVariance:
  detects:
    - inter_country variance
    - cross-spine divergence
  trigger:
    IF variance(country.avg(S.Z5.Transfer)) > Theta.WorldVarianceMax
    THEN activate World.CohesionLoop
Panel.WorldFailureTop:
  output:
    - top_k FailureModes by prevalence (FM_ID list)
Panel.WorldRepairTop:
  output:
    - top_k RepairLoops activated (R_ID list)
Panel.WorldShadow:
  output:
    - shadow intensity map (country.avg(S.Z5.Shadow))

FenceOS.WorldTriggers:
  WT1:
    condition: global_avg(S.Z5.Transfer) < Theta.TransferMin
    action:
      - publish global alert: transfer_crisis
      - prioritize loops [R5,R6,R11,R10] across spines
      - freeze acceleration programs until recovery
  WT2:
    condition: global_avg(S.Z5.Burnout) > Theta.BurnoutMax
    action:
      - publish global alert: overload_crisis
      - prioritize loops [R7,R8,R9,R1] across spines
      - enforce recovery floor emphasis
  WT3:
    condition: global_avg(S.Z5.Repair) > Theta.RepairLatencyMax
    action:
      - publish global alert: repair_latency_crisis
      - prioritize loops [R12,R10,R2] across spines
      - mandate daily repair slot policy pattern

World.CohesionLoop:
  purpose:
    enforce schema stability and comparability without forcing identical education systems
  actions:
    - enforce sensor contract compliance
    - enforce threshold block version alignment
    - forbid term drift in published instances
    - require FailureMode.Trace format in atlas entries
    - promote validated local repairs into global repair library (versioned)

OUTPUT_CONTRACT:
  - list of linked national spines (Z6 registry)
  - world panels (health, variance, failures, repairs, shadow)
  - world-level stop-loss triggers
  - schema/threshold versions used
  - spine version stamp

SPEC_ID: CivOS.Thresholds.Education.WORLD.v1.0
STATUS: LOCKED
Theta.WorldVarianceMax: {value: null, unit: variance, description: max_allowed_global_variance}

SPEC_ID: CivOS.PageContract.Instance.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

PAGE_RULES:
R1: Must include VersionStamp.Standard.v1.0 at top + bottom
R2: Must include AI.Disambiguation.Block.v1.0 near top
R3: Must include Inheritance Block (SPEC_ID + INHERITS)
R4: Must include Sensor Contract block (even if null values)
R5: Must include FenceOS Stop-Loss block
R6: Must include FailureMode.Trace block if any failure mode is named
R7: Must not redefine CivOS primitives
R8: Must not rename sensors, gates, loops, phases, zoom levels

PAGE_TYPE: Z5_CITY_INSTANCE
BLOCK_ORDER (must match):
B00: VersionStamp (top)
B01: AI Disambiguation Block
B02: Instance Identity Block (INSTANCE_ID + aliases + parent spine)
B03: Inheritance Block (SPEC_ID + INHERITS)
B04: One-Screen Summary Panel (text + bullet KPIs)
B05: Panel.Pipeline (E0–E6 + G0–G6)
B06: Panel.LoadBuffer (L(t), B(t), R=D/G)
B07: Sensors Table (S.Z5.* records)
B08: Thresholds Used (Theta block reference)
B09: Failure Clusters Present (GF list)
B10: Top Failure Modes (FM list; each with Trace)
B11: Repair Routes Activated (R list)
B12: FenceOS Stop-Loss Rules (T1/T2 etc)
B13: Output Contract Confirmation (checklist)
B99: VersionStamp (bottom)

PAGE_TYPE: Z6_SPINE
BLOCK_ORDER (must match):
B00: VersionStamp (top)
B01: AI Disambiguation Block
B02: Spine Identity Block (SPINE_ID + coverage registry)
B03: Inheritance Block (SPEC_ID + INHERITS)
B04: Registry Blocks (Z5 instances, sensors standard, thresholds, atlas)
B05: Spine Panels (NationalHealth / Variance / Shadow / RepairCapacity)
B06: Aggregate Sensors Output (country aggregates)
B07: Thresholds Used (Theta block reference)
B08: Top Failure Modes (FM list; with Trace)
B09: Top Repair Routes (R list)
B10: Spine FenceOS Triggers (ST*)
B11: Output Contract Confirmation (checklist)
B99: VersionStamp (bottom)

SPEC_ID: VersionStamp.Standard.v1.0
STATUS: LOCKED
FORMAT (top and bottom):
--- 
CivOS_SPEC: <SPEC_ID>
CivOS_INHERITS: <comma-separated SPEC_IDs>
CivOS_STATUS: LOCKED
CivOS_VERSION_POLICY: forward_only
CivOS_RENAME_POLICY: prohibited
CivOS_LAST_UPDATED: <YYYY-MM-DD>
---

---
CivOS_SPEC: EducationOS.Z5.Instance.SGP-SIN.v1.0
CivOS_INHERITS: CivOS.Core.v1.0,EducationOS.Compressed.v1.0,CivOS.Z5.Instance.Template.v1.0
CivOS_STATUS: LOCKED
CivOS_VERSION_POLICY: forward_only
CivOS_RENAME_POLICY: prohibited
CivOS_LAST_UPDATED: 2026-02-18
---

SPEC_ID: AI.Disambiguation.Block.v1.0
STATUS: LOCKED
DISAMBIGUATION:
D1: Education != School
  Education := regeneration_pipeline for transferable capability
  School := one implementation channel (Z2 institution)
D2: Ministry of Education != Education
  MOE := GovernanceOS of Education (policy/control layer)
  Education := capability regeneration pipeline
D3: Civilisation != Infrastructure/Money
  Civilisation := time-domain regenerative capability throughput
  Money/Infrastructure := tools/artefacts (not the definition)
D4: Vocabulary != Word Count
  Vocabulary := node+bind capacity enabling idea compression + transfer
  Word count alone does not imply capability
D5: Exam Score != Transfer Reliability
  Scores can be P2 false plateaus
  Capability requires transfer across context + time pressure + variation

Must appear within top 15% of page content.

SPEC_ID: CivOS.Panel.InstanceSummary.v1.0
STATUS: LOCKED
FIELDS:
- InstanceID:
- Z:
- ParentSpine:
- CurrentPhaseEstimate: {P0|P1|P2|P3|unknown}
- RiskRatio R (D/G): {value|null}
- Top 3 Risks: [FM_ID...]
- Top 3 Repairs: [R_ID...]
- FenceOS Active: {true|false|unknown}

SPEC_ID: FailureMode.Trace.Template.v1.0
INHERITS: CivOS.FailureMode.Atlas.v1.0
STATUS: LOCKED
TRACE_BLOCK:
FM_ID: <string>
OS: <EducationOS|VocabularyOS|GovernanceOS|...>
Z: <Z0..Z6>
P: <P0..P3>
NAME: <short>
TRIGGER:
  <condition_expression>
SENSOR_SET:
  - <S_ID...>
SIGNATURE:
  - <observable_pattern_1>
  - <observable_pattern_2>
  - <observable_pattern_3>
FAILURE_TRACE (mandatory):
  step_1: <Z? gap>
  step_2: <Z? instability>
  step_3: <P drift>
  step_4: <threshold breach>
  step_5: <collapse pocket>
  step_6: <repair route>
  step_7: <stitch to stable band>
ROOT_MECHANISM:
  <load|buffer|repair_latency|transfer|overconcentration|shadow_layer>
STOP_LOSS (FenceOS):
  <action_expression>
REPAIR_LOOPS:
  - <R_ID...>
EXIT_CRITERIA:
  <condition_expression>
EVIDENCE:
  - <case_id_or_link_placeholder>

FM_ID: FM.EDU.MODEL.001
OS: EducationOS
Z: Z0
P: P1->P2_false_plateau
NAME: practice_without_model
TRIGGER:
  high_practice_volume AND missing_worked_model
SENSOR_SET:
  - S.Z5.Drift
  - S.Z5.Transfer
  - S.Z5.Repair
SIGNATURE:
  - “I did many questions but still can’t do new ones”
  - performance collapses on small format change
  - repeated same mistakes
FAILURE_TRACE:
  step_1: Z0 model_gap (no concept map / worked example schema)
  step_2: Z0 pattern_repetition (rote drilling)
  step_3: P1 fragile competence mistaken as P2
  step_4: threshold breach (variation introduced)
  step_5: collapse pocket (timed/novel set failure)
  step_6: repair route (install model + error taxonomy)
  step_7: stitch to stable band (retrieval + variation + transfer)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  freeze_new_topics AND enforce G2(model_lock)
REPAIR_LOOPS:
  - R3 (model_install)
  - R10 (error_taxonomy_lock)
  - R4 (retrieval_training)
  - R5 (variation_injection)
EXIT_CRITERIA:
  KPI.P3 >= Theta.TransferMin for 3 consecutive cycles
EVIDENCE:
  - null

FM_ID: FM.EDU.MEM.002
OS: EducationOS
Z: Z0
P: P2_false_plateau
NAME: memorisation_false_plateau
TRIGGER:
  high_score_on_repeated_items AND low_novel_transfer
SENSOR_SET:
  - S.Z5.Transfer
  - S.Z5.Drift
SIGNATURE:
  - good at familiar worksheets, fails new papers
  - “I know it” but can’t start
  - collapses under time
FAILURE_TRACE:
  step_1: Z0 retrieval_gap (recognition not recall)
  step_2: Z0 low_variation exposure
  step_3: P2 appearance without P3 transfer
  step_4: threshold breach (novel framing + time pressure)
  step_5: collapse pocket (exam shock)
  step_6: repair route (timed retrieval + mixed sets)
  step_7: stitch to stable band (transfer bridge installed)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  replace repetition_blocks with timed_retrieval + variation
REPAIR_LOOPS:
  - R4 (retrieval_training)
  - R5 (variation_injection)
  - R6 (transfer_bridge)
  - R11 (test_simulation_loop)
EXIT_CRITERIA:
  KPI.P3 >= Theta.TransferMin under timed conditions
EVIDENCE:
  - null

FM_ID: FM.EDU.LANG.003
OS: EducationOS
Z: Z0
P: P1
NAME: weak_language_bind
TRIGGER:
  frequent_misread_questions OR cannot_follow_multistep_instructions
SENSOR_SET:
  - S.Z5.Transfer
  - S.Z5.Repair
SIGNATURE:
  - answers wrong question
  - skips constraints (“explain”, “compare”, “justify”)
  - loses marks despite knowing content
FAILURE_TRACE:
  step_1: Z0 language_bind_gap (keywords/connectors missing)
  step_2: Z0 wrong plan selection
  step_3: P1 fragile output despite knowledge
  step_4: threshold breach (complex prompts)
  step_5: collapse pocket (paper performance unpredictable)
  step_6: repair route (instruction grammar + parsing drills)
  step_7: stitch to stable band (stable prompt decoding)
ROOT_MECHANISM:
  repair_latency (because mis-parsing persists without targeted repair)
STOP_LOSS (FenceOS):
  enforce daily parsing_slot before content practice
REPAIR_LOOPS:
  - R2 (comprehension_repair)
  - R10 (error_taxonomy_lock)
  - R4 (retrieval_training)
EXIT_CRITERIA:
  misread_rate <= threshold for 3 cycles
EVIDENCE:
  - null

FM_ID: FM.EDU.TIME.004
OS: EducationOS
Z: Z0
P: P2_load_sensitive
NAME: timed_untimed_gap
TRIGGER:
  untimed_accuracy_high AND timed_accuracy_drop_high
SENSOR_SET:
  - S.Z5.Drift
  - S.Z5.L
  - S.Z5.B
SIGNATURE:
  - “I can do it at home”
  - freezes when timer starts
  - careless errors spike under speed
FAILURE_TRACE:
  step_1: Z0 load_training_gap (no pressure conditioning)
  step_2: Z0 working_memory overload
  step_3: P2 load-sensitive competence
  step_4: threshold breach (time pressure)
  step_5: collapse pocket (paper incomplete / careless cascade)
  step_6: repair route (timed retrieval ladder + load shedding)
  step_7: stitch to stable band (stable throughput under timer)
ROOT_MECHANISM:
  load
STOP_LOSS (FenceOS):
  cap difficulty + enforce timed_microsets daily
REPAIR_LOOPS:
  - R4 (retrieval_training)
  - R7 (pressure_safety)
  - R8 (deceleration)
  - R11 (test_simulation_loop)
EXIT_CRITERIA:
  S.Z5.Drift <= Theta.DriftMax in timed sets
EVIDENCE:
  - null

FM_ID: FM.EDU.OVERLOAD.005
OS: EducationOS
Z: Z0
P: P2->P1
NAME: sleep_debt_spiral
TRIGGER:
  sustained_high_load AND sleep_floor_breached
SENSOR_SET:
  - S.Z5.L
  - S.Z5.B
  - S.Z5.Burnout
SIGNATURE:
  - irritability, tears, avoidance
  - retention drops despite effort
  - weekend “crash” cycles
FAILURE_TRACE:
  step_1: Z0 buffer_gap (sleep/recovery deficit)
  step_2: Z0 attention instability
  step_3: P2 degrades to P1
  step_4: threshold breach (burnout tail begins)
  step_5: collapse pocket (shutdown / refusal / illness)
  step_6: repair route (load shedding + buffer rebuild)
  step_7: stitch to stable band (restore sleep floor + lower load)
ROOT_MECHANISM:
  buffer
STOP_LOSS (FenceOS):
  mandatory_load_shed AND enforce G0(sleep_floor)
REPAIR_LOOPS:
  - R1 (buffer_build)
  - R7 (pressure_safety)
  - R8 (deceleration)
  - R9 (schedule_rebalance)
EXIT_CRITERIA:
  S.Z5.B >= Theta.SleepFloor AND S.Z5.Burnout <= Theta.BurnoutMax
EVIDENCE:
  - null

FM_ID: FM.EDU.SHADOW.006
OS: EducationOS
Z: Z2->Z0
P: P2_load_sensitive
NAME: shadow_layer_overrun
TRIGGER:
  S.Z5.Shadow high AND model_lock weak AND repair_latency high
SENSOR_SET:
  - S.Z5.Shadow
  - S.Z5.Repair
  - S.Z5.Burnout
SIGNATURE:
  - tuition stack grows but stability worsens
  - dependency on “spoonfeeding”
  - burnout increases while grades stagnate
FAILURE_TRACE:
  step_1: Z2 coordination gap (channels conflict)
  step_2: Z0 cognitive overload (too many methods)
  step_3: P2 becomes unstable under routine load
  step_4: threshold breach (repair latency exceeds cycle)
  step_5: collapse pocket (burnout + learning aversion)
  step_6: repair route (unify method + reduce channels + repair discipline)
  step_7: stitch to stable band (single model + controlled practice)
ROOT_MECHANISM:
  shadow_layer
STOP_LOSS (FenceOS):
  cap_shadow_hours AND enforce single_method_policy
REPAIR_LOOPS:
  - R9 (schedule_rebalance)
  - R3 (model_install)
  - R12 (autonomy_scaffold)
  - R7 (pressure_safety)
EXIT_CRITERIA:
  S.Z5.Shadow <= Theta.ShadowMax AND S.Z5.Repair <= Theta.RepairLatencyMax
EVIDENCE:
  - null

FM_ID: FM.EDU.VAR.007
OS: EducationOS
Z: Z0
P: P2_false_plateau
NAME: low_variation_lock_in
TRIGGER:
  repeated_same_format_training AND weak_novel_performance
SENSOR_SET:
  - S.Z5.Transfer
  - S.Z5.Drift
SIGNATURE:
  - only can do “type A” questions
  - panic when diagram/wording changes
  - cannot generalize method
FAILURE_TRACE:
  step_1: Z0 corridor_narrowing (single pattern)
  step_2: Z0 brittle binds (no general schema)
  step_3: P2 appears stable until variation
  step_4: threshold breach (mixed / unfamiliar)
  step_5: collapse pocket (exam question diversity)
  step_6: repair route (systematic variation injection)
  step_7: stitch to stable band (transfer becomes robust)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  enforce mixed_sets_ratio >= threshold
REPAIR_LOOPS:
  - R5 (variation_injection)
  - R6 (transfer_bridge)
  - R11 (test_simulation_loop)
EXIT_CRITERIA:
  KPI.P3 >= Theta.TransferMin on mixed sets
EVIDENCE:
  - null

FM_ID: FM.EDU.LATENCY.008
OS: EducationOS
Z: Z0
P: P2->P1
NAME: repair_latency_exceeds_cycle
TRIGGER:
  S.Z5.Repair > Theta.RepairLatencyMax
SENSOR_SET:
  - S.Z5.Repair
  - S.Z5.Drift
  - S.Z5.Transfer
SIGNATURE:
  - same errors persist for weeks
  - “we will fix later” becomes permanent
  - gaps compound
FAILURE_TRACE:
  step_1: Z0 defect unpatched
  step_2: Z0 compounding gaps
  step_3: P2 reliability decays
  step_4: threshold breach (new topic depends on old gap)
  step_5: collapse pocket (spiral: confusion -> avoidance)
  step_6: repair route (daily repair slot + error taxonomy)
  step_7: stitch to stable band (latency below cycle length)
ROOT_MECHANISM:
  repair_latency
STOP_LOSS (FenceOS):
  enforce daily_repair_slot AND freeze_new_dependency_topics
REPAIR_LOOPS:
  - R12 (autonomy_scaffold)
  - R10 (error_taxonomy_lock)
  - R2 (comprehension_repair)
  - R9 (schedule_rebalance)
EXIT_CRITERIA:
  S.Z5.Repair <= Theta.RepairLatencyMax for 2 cycles
EVIDENCE:
  - null

FM_ID: FM.EDU.PRESSURE.009
OS: EducationOS
Z: Z1->Z0
P: P1
NAME: pressure_without_safety
TRIGGER:
  high_expectations AND punitive_feedback AND low_buffer
SENSOR_SET:
  - S.Z5.B
  - S.Z5.Burnout
  - S.Z5.Transfer
SIGNATURE:
  - fear-driven studying
  - avoidance / lying about work
  - short bursts then collapse
FAILURE_TRACE:
  step_1: Z1 safety_gap (home feedback loop punitive)
  step_2: Z0 regulation collapse under stress
  step_3: P1 fragile output
  step_4: threshold breach (stakes increase)
  step_5: collapse pocket (burnout tail + disengagement)
  step_6: repair route (install Pressure-Safety Loop)
  step_7: stitch to stable band (pressure becomes training, not threat)
ROOT_MECHANISM:
  buffer
STOP_LOSS (FenceOS):
  enforce safety_protocol AND reduce stakes temporarily
REPAIR_LOOPS:
  - R7 (pressure_safety)
  - R1 (buffer_build)
  - R9 (schedule_rebalance)
EXIT_CRITERIA:
  S.Z5.Burnout <= Theta.BurnoutMax AND KPI.P3 recovers
EVIDENCE:
  - null

FM_ID: FM.EDU.ROUTING.010
OS: EducationOS
Z: Z2->Z0
P: P2_load_sensitive
NAME: method_conflict_routing_noise
TRIGGER:
  multiple_teachers_multiple_methods AND no_single_model_lock
SENSOR_SET:
  - S.Z5.Repair
  - S.Z5.Drift
  - S.Z5.Burnout
SIGNATURE:
  - child asks “which method do you want?”
  - inconsistent steps each day
  - confidence drops
FAILURE_TRACE:
  step_1: Z2 routing_conflict (channels misaligned)
  step_2: Z0 bind_noise (templates compete)
  step_3: P2 becomes unstable
  step_4: threshold breach (timer + novel set)
  step_5: collapse pocket (panic + regression)
  step_6: repair route (single canonical model + channel alignment)
  step_7: stitch to stable band (stable method under load)
ROOT_MECHANISM:
  shadow_layer
STOP_LOSS (FenceOS):
  enforce single_method_policy AND unify instruction templates
REPAIR_LOOPS:
  - R3 (model_install)
  - R10 (error_taxonomy_lock)
  - R9 (schedule_rebalance)
  - R12 (autonomy_scaffold)
EXIT_CRITERIA:
  S.Z5.Repair <= Theta.RepairLatencyMax AND drift decreases
EVIDENCE:
  - null

SPEC_ID: VocabularyOS.Compressed.v1.0
INHERITS: CivOS.Core.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

PURPOSE:
  increase idea_throughput by expanding:
    - nodes (words/phrases)
    - binds (connectors/collocations/grammar patterns)
  so that:
    - ideas compress into stable sentences
    - retrieval works under load
    - transfer works across contexts

OBJECTS:
Node:
  type: word|phrase|chunk
  attributes: meaning, usage, register, examples
Bind:
  type: connector|collocation|grammar_frame|semantic_link
  attributes: directionality, strength, evidence
Idea:
  emerges_from: activation_over(Node + Bind graph)

VocabularyCapability :=
  produce_correct + appropriate language under:
    - time pressure
    - context shift
    - audience shift
    - narrative constraint

SENSORS:
S.VOC.NodeCount.Active:        size(active_node_set)
S.VOC.BindStrength:            avg(bind_strength)
S.VOC.RetrievalLatency:        time_to_recall(target_word)
S.VOC.ProductionRate:          correct_words_per_minute
S.VOC.ColliderErrors:          wrong_word_due_to_nearby_meaning
S.VOC.RegisterDrift:           mismatch(formality/audience)
S.VOC.NarrativeIntegrity:      continuity_score across paragraphs

GATES:
V0: meaning_lock (can explain + use)
V1: sentence_lock (can place correctly in sentence)
V2: connector_lock (binds to connectors)
V3: retrieval_lock (timed recall)
V4: variation_lock (different topics + prompts)
V5: narrative_lock (supports story continuity)
V6: transfer_lock (writes under exam constraints)

IF gate_fail(Vk) THEN do_not_advance AND assign repair_loop

VR1: node_install (meaning+examples)
VR2: bind_install (collocations+connectors)
VR3: retrieval_drill (timed recall)
VR4: production_drill (write/speak output)
VR5: collision_map (near-meaning disambiguation)
VR6: register_training (audience/formality)
VR7: narrative_scaffold (continuity)
VR8: constraint_training (word limit / prompt constraints)
VR9: error_taxonomy_lock
VR10: transfer_bridge (new context writing)

FM_ID: FM.VOC.NODE.001
OS: VocabularyOS
Z: Z0
P: P1
NAME: missing_node_expression_block
TRIGGER:
  attempt_expression AND required_node_absent
SENSOR_SET:
  - S.VOC.NodeCount.Active
  - S.VOC.ProductionRate
SIGNATURE:
  - repeats “good / nice / bad” frequently
  - pauses mid-sentence
  - substitutes wrong simple word
FAILURE_TRACE:
  step_1: Z0 node_gap (word absent)
  step_2: Z0 forced substitution (low precision)
  step_3: P1 fragile output
  step_4: threshold breach (needs nuance)
  step_5: collapse pocket (idea truncates)
  step_6: repair route (node_install + sentence_lock)
  step_7: stitch to stable band (node becomes usable)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  pause_output AND install node before continuing essay
REPAIR_LOOPS:
  - VR1
  - VR4
  - VR9
EXIT_CRITERIA:
  node_used_correctly in 5 varied sentences
EVIDENCE:
  - null

FM_ID: FM.VOC.BIND.002
OS: VocabularyOS
Z: Z0
P: P1->P2_false_plateau
NAME: weak_bind_connection_failure
TRIGGER:
  has_words BUT cannot_chain_into_sentences
SENSOR_SET:
  - S.VOC.BindStrength
  - S.VOC.NarrativeIntegrity
SIGNATURE:
  - fragmented sentences
  - awkward phrasing
  - “I know many words but can’t write”
FAILURE_TRACE:
  step_1: Z0 bind_gap (connectors/collocations missing)
  step_2: Z0 sentence instability
  step_3: P2 appearance (word knowledge) without production
  step_4: threshold breach (longer writing)
  step_5: collapse pocket (paragraph breaks down)
  step_6: repair route (bind_install + connector_lock)
  step_7: stitch to stable band (stable sentence chains)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  stop word-listing; enforce bind-first training
REPAIR_LOOPS:
  - VR2
  - VR4
  - VR7
EXIT_CRITERIA:
  continuity_score >= target across 2 paragraphs
EVIDENCE:
  - null

FM_ID: FM.VOC.RETR.003
OS: VocabularyOS
Z: Z0
P: P2_load_sensitive
NAME: retrieval_latency_collapse
TRIGGER:
  time_pressure AND recall_time_high
SENSOR_SET:
  - S.VOC.RetrievalLatency
  - S.VOC.ProductionRate
SIGNATURE:
  - freezes under timer
  - writes simpler words only
  - incomplete sentences
FAILURE_TRACE:
  step_1: Z0 retrieval_latency high
  step_2: Z0 output slows
  step_3: P2 load-sensitive writing
  step_4: threshold breach (exam time)
  step_5: collapse pocket (short, weak composition)
  step_6: repair route (timed retrieval drills)
  step_7: stitch to stable band (fast recall under load)
ROOT_MECHANISM:
  load
STOP_LOSS (FenceOS):
  reduce complexity; enforce timed micro-drills daily
REPAIR_LOOPS:
  - VR3
  - VR4
  - VR8
EXIT_CRITERIA:
  retrieval_latency <= threshold for core set
EVIDENCE:
  - null

FM_ID: FM.VOC.COLLIDE.004
OS: VocabularyOS
Z: Z0
P: P2_false_plateau
NAME: collider_errors_near_meaning
TRIGGER:
  similar_words_present AND wrong_selection
SENSOR_SET:
  - S.VOC.ColliderErrors
  - S.VOC.RegisterDrift
SIGNATURE:
  - uses “jealous” when meaning “envious”
  - uses “scold” when meaning “warn”
  - wrong tone
FAILURE_TRACE:
  step_1: Z0 semantic collision
  step_2: Z0 wrong word inserted
  step_3: P2 looks advanced but is incorrect
  step_4: threshold breach (precision needed)
  step_5: collapse pocket (meaning distortion)
  step_6: repair route (collision_map + contrast pairs)
  step_7: stitch to stable band (correct selection)
ROOT_MECHANISM:
  repair_latency
STOP_LOSS (FenceOS):
  ban risky synonyms until contrast-pairs mastered
REPAIR_LOOPS:
  - VR5
  - VR1
  - VR9
EXIT_CRITERIA:
  collision_error_rate <= threshold across 3 prompts
EVIDENCE:
  - null

FM_ID: FM.VOC.REG.005
OS: VocabularyOS
Z: Z0
P: P2_load_sensitive
NAME: register_drift_audience_mismatch
TRIGGER:
  context_shift(audience/formality) AND mismatch_occurs
SENSOR_SET:
  - S.VOC.RegisterDrift
  - S.VOC.NarrativeIntegrity
SIGNATURE:
  - slang in formal compo
  - overly formal in dialogue
  - inconsistent voice
FAILURE_TRACE:
  step_1: Z0 register model missing
  step_2: Z0 tone mismatch
  step_3: P2 unstable across contexts
  step_4: threshold breach (prompt demands audience)
  step_5: collapse pocket (voice breaks, coherence drops)
  step_6: repair route (register training + templates)
  step_7: stitch to stable band (stable voice)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  enforce audience_tag per paragraph before writing
REPAIR_LOOPS:
  - VR6
  - VR7
  - VR9
EXIT_CRITERIA:
  register_drift <= threshold for 3 compositions
EVIDENCE:
  - null

FM_ID: FM.VOC.NARR.006
OS: VocabularyOS
Z: Z0
P: P2_load_sensitive
NAME: narrative_integrity_break
TRIGGER:
  multi_paragraph_output AND continuity_score_low
SENSOR_SET:
  - S.VOC.NarrativeIntegrity
  - S.VOC.BindStrength
SIGNATURE:
  - sudden topic jumps
  - character actions inconsistent
  - ending unrelated
FAILURE_TRACE:
  step_1: Z0 weak narrative scaffold (no plan binds)
  step_2: Z0 paragraph-to-paragraph binds break
  step_3: P2 collapses under length
  step_4: threshold breach (long prompt / exam)
  step_5: collapse pocket (story incoherent)
  step_6: repair route (narrative scaffold + connector binds)
  step_7: stitch to stable band (continuity restored)
ROOT_MECHANISM:
  load
STOP_LOSS (FenceOS):
  enforce story plan before writing (minimum 5-box)
REPAIR_LOOPS:
  - VR7
  - VR2
  - VR8
EXIT_CRITERIA:
  continuity_score >= target in 2 long compositions
EVIDENCE:
  - null

FM_ID: FM.VOC.CONN.007
OS: VocabularyOS
Z: Z0
P: P1
NAME: connector_collapse_logic_link_failure
TRIGGER:
  needs_cause_compare_contrast AND connector_set_missing
SENSOR_SET:
  - S.VOC.BindStrength
  - S.VOC.ProductionRate
SIGNATURE:
  - repetitive “and then”
  - weak causal explanations
  - arguments feel flat
FAILURE_TRACE:
  step_1: Z0 connector node/bind gap
  step_2: Z0 logic chain breaks
  step_3: P1 output shallow
  step_4: threshold breach (expository / argumentative)
  step_5: collapse pocket (cannot justify/explain)
  step_6: repair route (connector library + drills)
  step_7: stitch to stable band (logic links stable)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  require 3 connectors per paragraph until stable
REPAIR_LOOPS:
  - VR2
  - VR4
  - VR9
EXIT_CRITERIA:
  correct connector usage across 3 genres
EVIDENCE:
  - null

FM_ID: FM.VOC.LIST.008
OS: VocabularyOS
Z: Z0
P: P2_false_plateau
NAME: wordlist_trap_nodes_without_binds
TRIGGER:
  high_node_install AND low_production_quality
SENSOR_SET:
  - S.VOC.NodeCount.Active
  - S.VOC.BindStrength
  - S.VOC.NarrativeIntegrity
SIGNATURE:
  - “big words” inserted wrongly
  - awkward sentences
  - teacher comments: “forced vocabulary”
FAILURE_TRACE:
  step_1: Z0 nodes added without binds
  step_2: Z0 unstable insertion attempts
  step_3: P2 appearance of sophistication
  step_4: threshold breach (marking for clarity)
  step_5: collapse pocket (clarity penalty)
  step_6: repair route (bind_install + sentence templates)
  step_7: stitch to stable band (natural usage)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  prohibit new words unless paired with 3 binds + 3 sentences
REPAIR_LOOPS:
  - VR2
  - VR4
  - VR8
EXIT_CRITERIA:
  new words used naturally across 2 compositions
EVIDENCE:
  - null

FM_ID: FM.VOC.CONSTRAINT.009
OS: VocabularyOS
Z: Z0
P: P2_load_sensitive
NAME: constraint_violation_prompt_drift
TRIGGER:
  prompt_constraints_present AND frequent_violation
SENSOR_SET:
  - S.VOC.NarrativeIntegrity
  - S.VOC.ProductionRate
SIGNATURE:
  - exceeds word limit
  - ignores scenario requirements
  - off-topic endings
FAILURE_TRACE:
  step_1: Z0 constraint bind missing
  step_2: Z0 narrative expands uncontrolled
  step_3: P2 collapses under rules
  step_4: threshold breach (exam marking)
  step_5: collapse pocket (content penalty)
  step_6: repair route (constraint training + checklist)
  step_7: stitch to stable band (rules held under load)
ROOT_MECHANISM:
  load
STOP_LOSS (FenceOS):
  enforce pre-write constraint checklist + mid-write cap
REPAIR_LOOPS:
  - VR8
  - VR7
  - VR9
EXIT_CRITERIA:
  constraint_violation_rate <= threshold in 3 timed tasks
EVIDENCE:
  - null

FM_ID: FM.VOC.TRANSFER.010
OS: VocabularyOS
Z: Z0
P: P2_false_plateau
NAME: genre_transfer_failure
TRIGGER:
  success_in_genre_A AND failure_in_genre_B
SENSOR_SET:
  - S.VOC.TransferBridge (implicit via performance across genres)
  - S.VOC.BindStrength
SIGNATURE:
  - good story, weak situational writing
  - cannot do reflective/expository
  - same phrases reused everywhere
FAILURE_TRACE:
  step_1: Z0 bind set specialized to one genre
  step_2: Z0 missing cross-genre connectors
  step_3: P2 appears stable in one corridor
  step_4: threshold breach (genre swap)
  step_5: collapse pocket (writing quality drops)
  step_6: repair route (transfer bridge across genres)
  step_7: stitch to stable band (portable language frames)
ROOT_MECHANISM:
  transfer
STOP_LOSS (FenceOS):
  rotate genres weekly until transfer stabilizes
REPAIR_LOOPS:
  - VR10
  - VR2
  - VR4
EXIT_CRITERIA:
  stable performance across 3 genres under time
EVIDENCE:
  - null

SPEC_ID: IdeaLattice.Schema.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - CivOS.Graph.Schema.v1.0
  - VocabularyOS.Compressed.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

IdeaLattice := Graph( Nodes, Binds )
Nodes:
  type: word|phrase|chunk|concept_token
  fields: meaning, examples, register, alias_set
Binds:
  type: connector|collocation|syntax_frame|semantic_link|causal_link
  fields: direction, strength, evidence
Activation:
  A(node) ∈ [0,1]
  A(bind) ∈ [0,1]
Idea:
  emerges_when:
    exists subgraph G* such that:
      - activation_density(G*) >= Theta.ActivationDensity
      - coherence(G*) >= Theta.Coherence
      - constraint_satisfaction(G*) == TRUE

Regeneration (G_dot):
  rate of producing coherent, constrained sentences/ideas under load
Decay (D_dot):
  rate of truncation, contradiction, drift, and retrieval failure under load
STABILITY:
  G_dot >= D_dot
COLLAPSE:
  G_dot < D_dot

IDEA_COLLAPSE_MODES:
IC1: TruncationCollapse
  description: idea stops mid-chain (missing node/bind or low activation)
IC2: CoherenceCollapse
  description: contradictions / discontinuity / topic drift
IC3: LoadCollapse
  description: under time pressure, idea compresses to simplistic form
IC4: MisbindCollapse
  description: wrong connectors cause wrong inference (causal error)
IC5: ConstraintCollapse
  description: violates prompt, word limit, audience, or task type

SENSORS:
S.IDEA.ActivationDensity:
  definition: avg activation over required subgraph
S.IDEA.Coherence:
  definition: non-contradiction + continuity score
S.IDEA.ConstraintSatisfaction:
  definition: meets prompt constraints, audience, length
S.IDEA.RetrievalLatency:
  definition: time-to-recall critical nodes/binds
S.IDEA.Drift:
  definition: divergence from intended plan over time
S.IDEA.CollapseRate:
  definition: probability(collapse | load)

FenceOS.IdeaTriggers:
IT1:
  condition: S.IDEA.ConstraintSatisfaction == FALSE
  action: stop_output AND run ConstraintRepairLoop
IT2:
  condition: S.IDEA.Coherence < Theta.CoherenceMin
  action: stop_output AND run CoherenceRepairLoop
IT3:
  condition: S.IDEA.RetrievalLatency > Theta.RetrievalLatencyMax
  action: simplify + recall_drill + recompose

SPEC_ID: IdeaLattice.StressTests.v1.0
INHERITS:
  - IdeaLattice.Schema.v1.0
STATUS: LOCKED

ST1: PromptShift
  change: same topic, new framing
  pass_if: coherence maintained AND constraints met
ST2: AudienceShift
  change: child -> adult -> expert
  pass_if: register correct AND idea stable
ST3: TimeLimit
  change: compress time by 50%
  pass_if: no load collapse AND key binds remain
ST4: CounterArgument
  change: introduce strongest objection
  pass_if: idea survives and updates without contradiction
ST5: DataInjection
  change: add new fact mid-way
  pass_if: integrates without drift
ST6: ConstraintTightening
  change: word limit -30%
  pass_if: preserves core idea
ST7: GenreSwap
  change: narrative -> expository -> argumentative
  pass_if: transfers across genres
ST8: NoiseInjection
  change: insert irrelevant distractor
  pass_if: ignores distractor and stays on plan
ST9: ReversalTest
  change: invert key assumption
  pass_if: recompute conclusion cleanly
ST10: MultiHopReason
  change: require 3-step causal chain
  pass_if: no missing binds, no misbinds
ST11: SummarizeThenExpand
  change: 1 sentence -> 1 paragraph
  pass_if: expansion consistent with summary
ST12: RetrievalAfterDelay
  change: re-run after time gap
  pass_if: recall stable and output consistent

OUTPUTS:
- pass_fail per ST*
- failure_signature per failed test
- collapse_mode mapping (IC1..IC5)
- repair_loop assignment

SPEC_ID: IdeaPromotion.Rubric.v1.0
INHERITS:
  - IdeaLattice.Schema.v1.0
  - IdeaLattice.StressTests.v1.0
STATUS: LOCKED

IP0: non-idea / incoherent
IP1: fragile draft (works only in original framing)
IP2: functional but load-sensitive (fails some stress tests)
IP3: canonical (stable under stress + transfers across contexts)

PG0: DefinitionLock
  must define key terms / scope
PG1: CoherenceLock
  S.IDEA.Coherence >= Theta.CoherenceMin
PG2: ConstraintLock
  S.IDEA.ConstraintSatisfaction == TRUE
PG3: StressPassCore
  must pass: ST1, ST3, ST4, ST6
PG4: TransferLock
  must pass: ST2 (audience), ST7 (genre)
PG5: DriftLock
  S.IDEA.Drift <= Theta.DriftMax
PG6: DelayRecallLock
  must pass: ST12

IF any PG fails
  THEN do_not_promote
  AND assign repair loop based on collapse_mode

REPAIR_MAP:
IC1 TruncationCollapse -> {NodeInstall, BindInstall, RetrievalDrill}
IC2 CoherenceCollapse  -> {OutlineRepair, LogicBindRepair, RemoveContradictions}
IC3 LoadCollapse       -> {CompressionTraining, TimedRecompose, SimplifyThenExpand}
IC4 MisbindCollapse    -> {ConnectorRepair, CausalChainCheck, ContrastPairs}
IC5 ConstraintCollapse -> {ConstraintChecklist, PromptParseRepair, WordLimitRewrite}

CANONICAL_STAMP:
  IdeaStatus: IP3
  Evidence: [StressTestResults]
  Version: v1.0
  LockedTerms: TRUE

SPEC_ID: IdeaLattice.Thresholds.v1.0
STATUS: LOCKED
Theta.ActivationDensity:      {value: null}
Theta.CoherenceMin:           {value: null}
Theta.RetrievalLatencyMax:    {value: null}
Theta.DriftMax:               {value: null}

SPEC_ID: CreativityOS.GeneratorSuite.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - IdeaLattice.Schema.v1.0
  - IdeaPromotion.Rubric.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

Generator:
  GEN_ID: string
  NAME: string
  INPUTS: [tokens|constraints|domain_nodes|goal]
  OUTPUT: IdeaDraft
  METHOD: steps[]
  FAILURE_MODES: [IC*...]
  DEFAULT_REPAIR: [RepairLoops...]

GEN_ID: GEN1
NAME: recombination_matrix
INPUTS:
  - NodeSets: [A,B,C]  # e.g., {education}, {load}, {repair}
  - Constraint: "must produce 1 new claim + 1 test"
METHOD:
  1) pick 1 node from each set
  2) bind with connector frame: {because, therefore, however}
  3) output: claim + stress_test_plan
OUTPUT:
  IdeaDraft(type="claim+test")

GEN_ID: GEN2
NAME: inversion_negative_void
INPUTS:
  - SystemLaw
  - Objective
METHOD:
  1) invert objective (what if it fails?)
  2) list missing primitives
  3) output failure trace + repair hooks
OUTPUT:
  IdeaDraft(type="negative_void_article_seed")

GEN_ID: GEN3
NAME: constraint_first_synthesis
INPUTS:
  - Constraints: [time, word_limit, audience]
  - Topic
METHOD:
  1) lock constraints
  2) generate minimal viable structure
  3) fill with nodes/binds that satisfy constraints
OUTPUT:
  IdeaDraft(type="bounded_solution")

GEN_ID: GEN4
NAME: analogy_bridge
INPUTS:
  - SourceOS
  - TargetOS
METHOD:
  1) map primitives (nodes/binds/sensors)
  2) propose 1 transferable invariant
  3) output mapping table
OUTPUT:
  IdeaDraft(type="mapping")

GEN_ID: GEN5
NAME: causal_chain_builder
INPUTS:
  - StartNode
  - EndNode
METHOD:
  1) require 3 binds (A->B->C->D)
  2) enforce non-contradiction
  3) output chain + weakest link
OUTPUT:
  IdeaDraft(type="causal_chain")

GEN_ID: GEN6
NAME: counterexample_miner
INPUTS:
  - Claim
METHOD:
  1) generate strongest counterexample
  2) refine claim scope
  3) output revised claim + boundary conditions
OUTPUT:
  IdeaDraft(type="scope_lock")

GEN_ID: GEN7
NAME: minimal_spec_compression
INPUTS:
  - Long explanation
METHOD:
  1) extract primitives
  2) express as {definitions, laws, gates, sensors}
  3) output spec block
OUTPUT:
  IdeaDraft(type="almost_code_spec")

GEN_ID: GEN8
NAME: stress_first_drafting
INPUTS:
  - Topic
METHOD:
  1) pre-run ST1, ST3, ST4, ST6 hypothetically
  2) draft only what survives
  3) output robust draft
OUTPUT:
  IdeaDraft(type="stress_hardened_draft")

GEN_ID: GEN9
NAME: template_mutation
INPUTS:
  - BaseTemplate
  - MutationBudget (<=3 changes)
METHOD:
  1) mutate 1–3 binds only
  2) keep terms locked
  3) output variant for transfer testing
OUTPUT:
  IdeaDraft(type="variant")

GEN_ID: GEN10
NAME: measurement_injection
INPUTS:
  - IdeaDraft
METHOD:
  1) assign 1–3 sensors
  2) propose thresholds
  3) output testable version
OUTPUT:
  IdeaDraft(type="sensorized_draft")

GEN_ID: GEN11
NAME: repair_loop_generator
INPUTS:
  - FailureTrace
METHOD:
  1) identify root mechanism (load/buffer/latency/transfer)
  2) choose minimal repair loops
  3) output stop-loss + repair plan
OUTPUT:
  IdeaDraft(type="repair_protocol")

GEN_ID: GEN12
NAME: directory_enumerator
INPUTS:
  - Lane
  - ZoomLevel
METHOD:
  1) enumerate NodeIDs with frozen grammar
  2) define binds
  3) output directory page skeleton
OUTPUT:
  IdeaDraft(type="directory_page")

SPEC_ID: MindOS.OperatorOracleVisionary.Gating.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - IdeaPromotion.Rubric.v1.0
STATUS: LOCKED

ROLES:
Operator:
  function: execute + maintain pipelines
  allowed_outputs: stable procedures, checklists, repairs
  forbidden: promote unstable ideas to canon
Oracle:
  function: metrics + sensors + thresholds + evaluations
  allowed_outputs: measurement specs, test harnesses, audits
  forbidden: define core laws without stress evidence
Visionary:
  function: corridor expansion (new nodes/binds)
  allowed_outputs: new hypotheses, new mappings
  constraint: must pass stress tests before promotion

ROLE_GATES:
Operator:
  may_generate: GEN7, GEN10, GEN11, GEN12
  may_promote_to_IP3: only if Oracle confirms gates PG0..PG6
Oracle:
  may_generate: GEN6, GEN10
  may_promote_to_IP3: YES, after evidence logged
Visionary:
  may_generate: GEN1..GEN12
  may_promote_to_IP3: NO (requires Oracle confirmation)

IF idea_not_passed(PG0..PG6)
  THEN label: IP1_or_IP2
  AND forbid: "canonical" language

repair_latency < stress_cycle_length
OR mind_state drifts into:
  - overconfidence
  - avoidance
  - template_overfit

SPEC_ID: ChronoHelmAI.GraphRunner.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - CivOS.Graph.Schema.v1.0
  - IdeaLattice.Schema.v1.0
  - IdeaLattice.StressTests.v1.0
  - IdeaPromotion.Rubric.v1.0
STATUS: LOCKED

NodeID Grammar:
  Place×Lane×Zoom×Role×Type×ID
Required Node Types:
  IdeaDraft
  StressTestResult
  RepairAction
  PromotionDecision
  EvidenceLog

RUNNER_LOOP:
Step 0: SelectRole
  input: {Operator|Oracle|Visionary}
Step 1: Generate
  input: GEN_ID + inputs
  output: IdeaDraft (IP1 default)
Step 2: Sensorize
  attach: S.IDEA.* sensors
  output: sensorized draft
Step 3: Stress
  run: ST1..ST12 (minimum core: ST1,ST3,ST4,ST6)
  output: StressTestResult set
  compute:
    - collapse_mode (IC1..IC5)
    - failure_signature
Step 4: Repair
  if any core test fails:
    map collapse_mode -> repair_loops
    apply repairs
    repeat stress
  else:
    proceed
Step 5: Promote
  evaluate PG0..PG6
  if pass:
    set status IP3
  else:
    keep IP2 and log missing gates
Step 6: LogEvidence
  write EvidenceLog:
    - inputs
    - outputs
    - stress results
    - repairs applied
    - promotion decision
    - version stamps

CANON_RULE:
  IP3 requires:
    - StressPassCore (PG3)
    - TransferLock (PG4)
    - DelayRecallLock (PG6)
    - EvidenceLog present

PUBLISHABLE_ARTIFACTS:
A1: Canonical Spec Page (Almost-Code)
  requires: IP3 + version stamp + disambiguation block
A2: FailureMode Atlas Entry
  requires: FailureMode.Trace + evidence link placeholder
A3: Directory Page
  requires: NodeID enumeration + binds + thresholds used

SPEC_ID: CreativityOS.GeneratorSuite.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - IdeaLattice.Schema.v1.0
  - IdeaPromotion.Rubric.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

Generator:
  GEN_ID: string
  NAME: string
  INPUTS: [tokens|constraints|domain_nodes|goal]
  OUTPUT: IdeaDraft
  METHOD: steps[]
  FAILURE_MODES: [IC*...]
  DEFAULT_REPAIR: [RepairLoops...]

GEN_ID: GEN1
NAME: recombination_matrix
INPUTS:
  - NodeSets: [A,B,C]  # e.g., {education}, {load}, {repair}
  - Constraint: "must produce 1 new claim + 1 test"
METHOD:
  1) pick 1 node from each set
  2) bind with connector frame: {because, therefore, however}
  3) output: claim + stress_test_plan
OUTPUT:
  IdeaDraft(type="claim+test")

GEN_ID: GEN2
NAME: inversion_negative_void
INPUTS:
  - SystemLaw
  - Objective
METHOD:
  1) invert objective (what if it fails?)
  2) list missing primitives
  3) output failure trace + repair hooks
OUTPUT:
  IdeaDraft(type="negative_void_article_seed")

GEN_ID: GEN3
NAME: constraint_first_synthesis
INPUTS:
  - Constraints: [time, word_limit, audience]
  - Topic
METHOD:
  1) lock constraints
  2) generate minimal viable structure
  3) fill with nodes/binds that satisfy constraints
OUTPUT:
  IdeaDraft(type="bounded_solution")

GEN_ID: GEN4
NAME: analogy_bridge
INPUTS:
  - SourceOS
  - TargetOS
METHOD:
  1) map primitives (nodes/binds/sensors)
  2) propose 1 transferable invariant
  3) output mapping table
OUTPUT:
  IdeaDraft(type="mapping")

GEN_ID: GEN5
NAME: causal_chain_builder
INPUTS:
  - StartNode
  - EndNode
METHOD:
  1) require 3 binds (A->B->C->D)
  2) enforce non-contradiction
  3) output chain + weakest link
OUTPUT:
  IdeaDraft(type="causal_chain")

GEN_ID: GEN6
NAME: counterexample_miner
INPUTS:
  - Claim
METHOD:
  1) generate strongest counterexample
  2) refine claim scope
  3) output revised claim + boundary conditions
OUTPUT:
  IdeaDraft(type="scope_lock")

GEN_ID: GEN7
NAME: minimal_spec_compression
INPUTS:
  - Long explanation
METHOD:
  1) extract primitives
  2) express as {definitions, laws, gates, sensors}
  3) output spec block
OUTPUT:
  IdeaDraft(type="almost_code_spec")

GEN_ID: GEN8
NAME: stress_first_drafting
INPUTS:
  - Topic
METHOD:
  1) pre-run ST1, ST3, ST4, ST6 hypothetically
  2) draft only what survives
  3) output robust draft
OUTPUT:
  IdeaDraft(type="stress_hardened_draft")

GEN_ID: GEN9
NAME: template_mutation
INPUTS:
  - BaseTemplate
  - MutationBudget (<=3 changes)
METHOD:
  1) mutate 1–3 binds only
  2) keep terms locked
  3) output variant for transfer testing
OUTPUT:
  IdeaDraft(type="variant")

GEN_ID: GEN10
NAME: measurement_injection
INPUTS:
  - IdeaDraft
METHOD:
  1) assign 1–3 sensors
  2) propose thresholds
  3) output testable version
OUTPUT:
  IdeaDraft(type="sensorized_draft")

GEN_ID: GEN11
NAME: repair_loop_generator
INPUTS:
  - FailureTrace
METHOD:
  1) identify root mechanism (load/buffer/latency/transfer)
  2) choose minimal repair loops
  3) output stop-loss + repair plan
OUTPUT:
  IdeaDraft(type="repair_protocol")

GEN_ID: GEN12
NAME: directory_enumerator
INPUTS:
  - Lane
  - ZoomLevel
METHOD:
  1) enumerate NodeIDs with frozen grammar
  2) define binds
  3) output directory page skeleton
OUTPUT:
  IdeaDraft(type="directory_page")

SPEC_ID: MindOS.OperatorOracleVisionary.Gating.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - IdeaPromotion.Rubric.v1.0
STATUS: LOCKED

ROLES:
Operator:
  function: execute + maintain pipelines
  allowed_outputs: stable procedures, checklists, repairs
  forbidden: promote unstable ideas to canon
Oracle:
  function: metrics + sensors + thresholds + evaluations
  allowed_outputs: measurement specs, test harnesses, audits
  forbidden: define core laws without stress evidence
Visionary:
  function: corridor expansion (new nodes/binds)
  allowed_outputs: new hypotheses, new mappings
  constraint: must pass stress tests before promotion

ROLE_GATES:
Operator:
  may_generate: GEN7, GEN10, GEN11, GEN12
  may_promote_to_IP3: only if Oracle confirms gates PG0..PG6
Oracle:
  may_generate: GEN6, GEN10
  may_promote_to_IP3: YES, after evidence logged
Visionary:
  may_generate: GEN1..GEN12
  may_promote_to_IP3: NO (requires Oracle confirmation)

IF idea_not_passed(PG0..PG6)
  THEN label: IP1_or_IP2
  AND forbid: "canonical" language

repair_latency < stress_cycle_length
OR mind_state drifts into:
  - overconfidence
  - avoidance
  - template_overfit

SPEC_ID: ChronoHelmAI.GraphRunner.v1.0
INHERITS:
  - CivOS.Core.v1.0
  - CivOS.Graph.Schema.v1.0
  - IdeaLattice.Schema.v1.0
  - IdeaLattice.StressTests.v1.0
  - IdeaPromotion.Rubric.v1.0
STATUS: LOCKED

SPEC_ID: WordPress.BlockPack.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

--- 
CivOS_SPEC: <SPEC_ID>
CivOS_INHERITS: <comma-separated SPEC_IDs>
CivOS_STATUS: LOCKED
CivOS_VERSION_POLICY: forward_only
CivOS_RENAME_POLICY: prohibited
CivOS_LAST_UPDATED: <YYYY-MM-DD>
---

SPEC_ID: AI.Disambiguation.Block.v1.0
STATUS: LOCKED
D1: Education != School
  Education := regeneration_pipeline for transferable capability
  School := one implementation channel (Z2 institution)
D2: Ministry of Education != Education
  MOE := GovernanceOS of Education (policy/control layer)
  Education := capability regeneration pipeline
D3: Civilisation != Infrastructure/Money
  Civilisation := time-domain regenerative capability throughput
  Money/Infrastructure := tools/artefacts (not the definition)
D4: Vocabulary != Word Count
  Vocabulary := node+bind capacity enabling idea compression + transfer
D5: Exam Score != Transfer Reliability
  Capability requires transfer across context + time pressure + variation

SPEC_ID: <this_page_spec_id>
INHERITS:
  - CivOS.Core.v1.0
  - <other_specs...>
STATUS: LOCKED

SPEC_ID: CivOS.Panel.InstanceSummary.v1.0
STATUS: LOCKED
- InstanceID:
- Z:
- ParentSpine:
- CurrentPhaseEstimate: {P0|P1|P2|P3|unknown}
- RiskRatio R (D/G): {value|null}
- Top 3 Risks: [FM_ID...]
- Top 3 Repairs: [R_ID...]
- FenceOS Active: {true|false|unknown}

SPEC_ID: WORLD.Sensors.Education.Z5.Standard.v1.0
STATUS: LOCKED
SensorRecord:
  SensorID: string
  value: number|null
  unit: string
  source: string|null
  measurement_window: string|null
  timestamp: ISO8601|null
  confidence: 0..1|null
REQUIRED_SENSORS_Z5:
  - S.Z5.L
  - S.Z5.B
  - S.Z5.Drift
  - S.Z5.Transfer
  - S.Z5.Repair
  - S.Z5.Burnout
  - S.Z5.Shadow

S.Z5.L:        {value: null, unit: hours/day,  source: null, measurement_window: null, timestamp: null, confidence: null}
S.Z5.B:        {value: null, unit: %,          source: null, measurement_window: null, timestamp: null, confidence: null}
S.Z5.Drift:    {value: null, unit: score_gap,  source: null, measurement_window: null, timestamp: null, confidence: null}
S.Z5.Transfer: {value: null, unit: %,          source: null, measurement_window: null, timestamp: null, confidence: null}
S.Z5.Repair:   {value: null, unit: days,       source: null, measurement_window: null, timestamp: null, confidence: null}
S.Z5.Burnout:  {value: null, unit: %,          source: null, measurement_window: null, timestamp: null, confidence: null}
S.Z5.Shadow:   {value: null, unit: index,      source: null, measurement_window: null, timestamp: null, confidence: null}

SPEC_ID: CivOS.Thresholds.Education.Z5.v1.0
STATUS: LOCKED
Theta.SleepFloor:       {value: null, unit: %}
Theta.BurnoutMax:       {value: null, unit: %}
Theta.DriftMax:         {value: null, unit: score_gap}
Theta.TransferMin:      {value: null, unit: %}
Theta.RepairLatencyMax: {value: null, unit: days}

SPEC_ID: FenceOS.Z5.StopLoss.v1.0
INHERITS: CivOS.Core.v1.0
STATUS: LOCKED
T1:
  condition: (S.Z5.B < Theta.SleepFloor) OR (S.Z5.Burnout > Theta.BurnoutMax)
  action: activate [R7,R8,R9,R1] AND enforce recovery_floor
T2:
  condition: (S.Z5.Drift > Theta.DriftMax) OR (S.Z5.Transfer < Theta.TransferMin)
  action: activate [R4,R5,R6,R10,R11] AND freeze_new_topics

SPEC_ID: FailureMode.Trace.Template.v1.0
STATUS: LOCKED
FM_ID:
OS:
Z:
P:
NAME:
TRIGGER:
SENSOR_SET:
SIGNATURE:
FAILURE_TRACE:
  step_1:
  step_2:
  step_3:
  step_4:
  step_5:
  step_6:
  step_7:
ROOT_MECHANISM:
STOP_LOSS (FenceOS):
REPAIR_LOOPS:
EXIT_CRITERIA:
EVIDENCE:

SPEC_BLOCK_START
<PASTE SPEC HERE>
SPEC_BLOCK_END

SPEC_ID: Index.Pages.v1.0
STATUS: LOCKED
VERSION_POLICY: forward_only
RENAME_POLICY: prohibited

PAGE: CivOS Core Hub
SPEC: CivOS.Core.v1.0
MUST_LINK:
1) CivOS Canonical
  - CivOS.Core.v1.0
  - CivOS.Graph.Schema.v1.0
  - CivOS.PageContract.Instance.v1.0
  - VersionStamp.Standard.v1.0
  - AI.Disambiguation.Block.v1.0
2) EducationOS Spine
  - EducationOS.Compressed.v1.0
  - CivOS.Thresholds.Education.Z5.v1.0
  - EducationOS.Z6.Spine.SGP.v1.0
  - EducationOS.Z6.Spine.JPN.v1.0
  - EducationOS.Z6.Spine.GBR.v1.0
  - EducationOS.Z6.Spine.WORLD.v1.0
  - EducationOS.Z5.Instance.* (cities)
3) Failure Atlas
  - CivOS.FailureMode.Atlas.v1.0
  - FailureMode.Trace.Template.v1.0
  - FM.EDU.* (10 traces)
  - FM.VOC.* (10 traces)
4) VocabularyOS → IdeaLattice
  - VocabularyOS.Compressed.v1.0
  - IdeaLattice.Schema.v1.0
  - IdeaLattice.StressTests.v1.0
  - IdeaPromotion.Rubric.v1.0
5) CreativityOS + MindOS + ChronoHelmAI
  - CreativityOS.GeneratorSuite.v1.0
  - MindOS.OperatorOracleVisionary.Gating.v1.0
  - ChronoHelmAI.GraphRunner.v1.0

INDEX_RULE:
  Every new OS page must:
    - declare SPEC_ID
    - list INHERITS
    - link back to CivOS Core Hub
    - use VersionStamp + Disambiguation block